_dbus_set_signal_handler (SIGHUP, signal_handler);
#endif /* DBUS_UNIX */
+ dbus_set_protocol_version (DBUS_MAJOR_PROTOCOL_VERSION);
+
_dbus_verbose ("We are on D-Bus...\n");
_dbus_loop_run (bus_context_get_loop (context));
AC_ARG_ENABLE(console-owner-file, AS_HELP_STRING([--enable-console-owner-file],[enable console owner file]),enable_console_owner_file=$enableval,enable_console_owner_file=auto)
AC_ARG_ENABLE(launchd, AS_HELP_STRING([--enable-launchd],[build with launchd auto-launch support]),enable_launchd=$enableval,enable_launchd=auto)
AC_ARG_ENABLE(systemd, AS_HELP_STRING([--enable-systemd],[build with systemd at_console support]),enable_systemd=$enableval,enable_systemd=auto)
+AC_ARG_ENABLE(kdbus-transport, AS_HELP_STRING([--enable-kdbus-transport],[build with kdbus transport support]),enable_kdbus_transport=$enableval,enable_kdbus_transport=no)
AC_ARG_WITH(init-scripts, AS_HELP_STRING([--with-init-scripts=[redhat]],[Style of init scripts to install]))
AC_ARG_WITH(session-socket-dir, AS_HELP_STRING([--with-session-socket-dir=[dirname]],[Where to put sockets for the per-login-session message bus]))
AC_DEFINE([WITH_VALGRIND], [1], [Define to add Valgrind instrumentation])
fi
+### kdbus support
+if test x$enable_kdbus_transport = xyes; then
+ AC_DEFINE(ENABLE_KDBUS_TRANSPORT,1,[Enable kdbus transport support])
+fi
+AM_CONDITIONAL([ENABLE_KDBUS_TRANSPORT], [test x$enable_kdbus_transport = xyes])
+
# Determine maximum number of Unix fds which may be passed
AS_CASE([$host_os],
[*qnx*],
AC_SUBST([DEFAULT_MESSAGE_UNIX_FDS])
#### Set up final flags
-LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs"
+LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs $KDBUS_LIBS"
AC_SUBST([LIBDBUS_LIBS])
### X11 detection
## and also to connect to. If this ever changes, it'll need to be split into
## two variables, one for the listening address and one for the connecting
## address.
-DBUS_SYSTEM_BUS_DEFAULT_ADDRESS="unix:path=$DBUS_SYSTEM_SOCKET"
+#AC_SUBST(DBUS_SYSTEM_BUS_DEFAULT_ADDRESS)
+if ! test -z "$with_system_default_bus"; then
+ ## Now system bus can work on kdbus too. It is diffrent situation than
+ ## described above (daemon working with kdbus doesn't need to listen on
+ ## any socket), so variable was not splited into two.
+ DBUS_SYSTEM_BUS_DEFAULT_ADDRESS=$with_system_default_bus
+else
+ DBUS_SYSTEM_BUS_DEFAULT_ADDRESS="unix:path=$DBUS_SYSTEM_SOCKET"
+fi
AC_SUBST(DBUS_SYSTEM_BUS_DEFAULT_ADDRESS)
AC_DEFINE_UNQUOTED(DBUS_SYSTEM_BUS_DEFAULT_ADDRESS, "$DBUS_SYSTEM_BUS_DEFAULT_ADDRESS",[The default D-Bus address of the system bus])
Building Doxygen docs: ${enable_doxygen_docs}
Building XML docs: ${enable_xml_docs}
Building launchd support: ${have_launchd}
+ Building kdbus support: ${enable_kdbus_transport}
Init scripts style: ${with_init_scripts}
Abstract socket names: ${ac_cv_have_abstract_sockets}
System bus socket: ${DBUS_SYSTEM_SOCKET}
sd-daemon.c \
sd-daemon.h
+DBUS_SHARED_arch_sources += \
+ dbus-transport-kdbus.c \
+ dbus-transport-kdbus.h \
+ kdbus-common.c \
+ kdbus-common.h \
+ dbus-signals.c \
+ dbus-signals.h \
+ dbus-marshal-gvariant.c \
+ dbus-marshal-gvariant.h \
+ dbus-protocol-gvariant.h
+
DBUS_UTIL_arch_sources = \
dbus-sysdeps-util-unix.c \
dbus-userdb-util.c \
$(DBUS_SHARED_arch_sources) \
dbus-sysdeps.c \
dbus-sysdeps.h \
- dbus-valgrind-internal.h
+ dbus-valgrind-internal.h \
+ dbus-asv-util.c \
+ dbus-asv-util.h \
+ dbus-string-util.c
### source code that is generic utility functionality used
### by the bus daemon or test apps, but is NOT included
### should be underscore-prefixed but don't really need
### to be unless they move to DBUS_SHARED_SOURCES later)
DBUS_UTIL_SOURCES= \
- dbus-asv-util.c \
- dbus-asv-util.h \
dbus-auth-script.c \
dbus-auth-script.h \
dbus-auth-util.c \
return TRUE;
}
+
+/**
+ * Create a new entry in an a{sv} (map from string to variant)
+ * with an array of bytes value.
+ *
+ * If this function fails, the a{sv} must be abandoned, for instance
+ * with _dbus_asv_abandon().
+ *
+ * @param arr_iter the iterator which is appending to the array
+ * @param key a UTF-8 key for the map
+ * @param value the value
+ * @returns #TRUE on success, or #FALSE if not enough memory
+ */
+dbus_bool_t
+_dbus_asv_add_array_of_bytes (DBusMessageIter *arr_iter,
+ const char *key,
+ const void *value,
+ unsigned int value_len)
+{
+ DBusMessageIter entry_iter, var_iter;
+
+ if (!_dbus_asv_open_entry (arr_iter, &entry_iter, key,
+ DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING,
+ &var_iter))
+ return FALSE;
+
+ if (!dbus_message_iter_append_fixed_array (&var_iter, DBUS_TYPE_BYTE,
+ &value, value_len))
+ {
+ _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
+ return FALSE;
+ }
+
+ if (!_dbus_asv_close_entry (arr_iter, &entry_iter, &var_iter))
+ return FALSE;
+
+ return TRUE;
+}
DBUS_BEGIN_DECLS
-DBusMessage *_dbus_asv_new_method_return (DBusMessage *message,
- DBusMessageIter *iter,
- DBusMessageIter *arr_iter);
-dbus_bool_t _dbus_asv_close (DBusMessageIter *iter,
- DBusMessageIter *arr_iter);
-void _dbus_asv_abandon (DBusMessageIter *iter,
- DBusMessageIter *arr_iter);
+DBusMessage *_dbus_asv_new_method_return (DBusMessage *message,
+ DBusMessageIter *iter,
+ DBusMessageIter *arr_iter);
+dbus_bool_t _dbus_asv_close (DBusMessageIter *iter,
+ DBusMessageIter *arr_iter);
+void _dbus_asv_abandon (DBusMessageIter *iter,
+ DBusMessageIter *arr_iter);
-dbus_bool_t _dbus_asv_add_uint32 (DBusMessageIter *arr_iter,
- const char *key,
- dbus_uint32_t value);
-dbus_bool_t _dbus_asv_add_string (DBusMessageIter *arr_iter,
- const char *key,
- const char *value);
+dbus_bool_t _dbus_asv_add_uint32 (DBusMessageIter *arr_iter,
+ const char *key,
+ dbus_uint32_t value);
+dbus_bool_t _dbus_asv_add_string (DBusMessageIter *arr_iter,
+ const char *key,
+ const char *value);
+dbus_bool_t _dbus_asv_add_array_of_bytes (DBusMessageIter *arr_iter,
+ const char *key,
+ const void *value,
+ unsigned int value_len);
#endif
return auth;
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+/**
+ * Creates a new auth conversation object for the client side of kdbus.
+ * In fact it only initialize structures and sets authenticated state
+ * because of different authentication-like mechanism in kdbus - policies
+ * TODO Probably to be checked and modified when kdbus will be documented
+ *
+ * @returns the new object or #NULL if no memory
+ */
+DBusAuth*
+_dbus_auth_client_new_kdbus (void)
+{
+ DBusAuth *auth;
+ DBusString guid_str;
+
+ if (!_dbus_string_init (&guid_str))
+ return NULL;
+
+ auth = _dbus_auth_new (sizeof (DBusAuthClient));
+ if (auth == NULL)
+ {
+ _dbus_string_free (&guid_str);
+ return NULL;
+ }
+
+ DBUS_AUTH_CLIENT (auth)->guid_from_server = guid_str;
+
+ auth->side = auth_side_client;
+ auth->state = &common_state_authenticated;
+ auth->unix_fd_negotiated = TRUE;
+
+ /* Start the auth conversation by sending AUTH for our default
+ * mechanism */
+/* if (!send_auth (auth, &all_mechanisms[0]))
+ {
+ _dbus_auth_unref (auth);
+ return NULL;
+ }*/
+
+ return auth;
+}
+#endif
+
/**
* Increments the refcount of an auth object.
*
DBusAuth* _dbus_auth_server_new (const DBusString *guid);
DBusAuth* _dbus_auth_client_new (void);
+#ifdef ENABLE_KDBUS_TRANSPORT
+DBusAuth* _dbus_auth_client_new_kdbus (void);
+#endif
DBusAuth* _dbus_auth_ref (DBusAuth *auth);
void _dbus_auth_unref (DBusAuth *auth);
dbus_bool_t _dbus_auth_set_mechanisms (DBusAuth *auth,
goto out;
}
+ if(_dbus_connection_is_kdbus(connection))
+ {
+ DBusMessageIter args;
+ dbus_uint32_t registration_flags = 0;
+
+ dbus_message_iter_init_append(message, &args);
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, ®istration_flags);
+ }
+
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
if (reply == NULL)
dbus_bool_t _dbus_connection_remove_message (DBusConnection *connection,
DBusMessage *message);
+int _dbus_connection_get_n_incoming (DBusConnection *connection);
+dbus_bool_t _dbus_connection_is_kdbus (DBusConnection *connection);
/* if DBUS_ENABLE_STATS */
void _dbus_connection_get_stats (DBusConnection *connection,
/* dbus-connection.c DBusConnection object
*
* Copyright (C) 2002-2006 Red Hat Inc.
+ * Copyright (C) 2013-2015 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
#include "dbus-message-private.h"
#include "dbus-threads.h"
#include "dbus-protocol.h"
+#include "dbus-protocol-gvariant.h"
#include "dbus-dataslot.h"
#include "dbus-string.h"
#include "dbus-signature.h"
#include <sys/smack.h>
#include <stdlib.h>
#endif
+#include "kdbus-common.h"
#ifdef DBUS_DISABLE_CHECKS
#define TOOK_LOCK_CHECK(connection)
"_dbus_conection_queue_received_message_link");
}
+static dbus_bool_t
+_dbus_connection_assure_protocol_version (DBusConnection *connection,
+ DBusMessage **message)
+{
+ DBusMessage *msg = *message;
+ dbus_bool_t conversion_needed = FALSE;
+ dbus_bool_t convert_to_gvariant = FALSE;
+ dbus_bool_t send_to_kdbus = _dbus_connection_is_kdbus (connection);
+
+ if (send_to_kdbus && msg->header.protocol_version != DBUS_PROTOCOL_VERSION_GVARIANT)
+ {
+ conversion_needed = TRUE;
+ convert_to_gvariant = TRUE;
+ }
+ else if (!send_to_kdbus && msg->header.protocol_version == DBUS_PROTOCOL_VERSION_GVARIANT)
+ {
+ conversion_needed = TRUE;
+ convert_to_gvariant = FALSE;
+ }
+
+ if (conversion_needed)
+ {
+ msg = _dbus_message_remarshal (msg, convert_to_gvariant);
+#if defined(DBUS_ENABLE_CHECKS)
+ {
+ DBusMessage *converted_again = _dbus_message_remarshal (*message, convert_to_gvariant);
+ DBusMessage *converted_back;
+ dbus_message_lock (converted_again);
+ converted_back = _dbus_message_remarshal (converted_again, !convert_to_gvariant);
+ dbus_message_lock (converted_back);
+
+ if (!_dbus_string_equal (&(*message)->body, &converted_back->body))
+ {
+ _dbus_abort();
+ }
+ dbus_message_unref (converted_again);
+ dbus_message_unref (converted_back);
+ }
+#endif
+ }
+
+ *message = msg;
+
+ return *message != NULL;
+}
+
/**
* Adds a link + message to the incoming message queue.
* Can't fail. Takes ownership of both link and message.
_dbus_connection_queue_synthesized_message_link (DBusConnection *connection,
DBusList *link)
{
+ DBusMessage *msg, *rmsg;
+
HAVE_LOCK_CHECK (connection);
-
+
+ msg = (DBusMessage *)link->data;
+
+ rmsg = msg;
+ _dbus_connection_assure_protocol_version (connection, &rmsg);
+
+ if (rmsg != msg) {
+ _dbus_list_free_link(link);
+ link = _dbus_list_alloc_link (rmsg);
+ }
+
_dbus_list_append_link (&connection->incoming_messages, link);
connection->n_incoming += 1;
{
dbus_uint32_t serial;
+ /* Finish preparing the message */
+ if (dbus_message_get_serial (message) == 0)
+ {
+ serial = _dbus_connection_get_next_client_serial (connection);
+ dbus_message_set_serial (message, serial);
+ if (client_serial)
+ *client_serial = serial;
+ }
+ else
+ {
+ if (client_serial)
+ *client_serial = dbus_message_get_serial (message);
+ }
+
+ _dbus_verbose ("Message %p serial is %u\n",
+ message, dbus_message_get_serial (message));
+
+ dbus_message_lock (message);
+
+ /* This convert message if neccessary */
+ _dbus_connection_assure_protocol_version (connection, &message);
+
preallocated->queue_link->data = message;
_dbus_list_prepend_link (&connection->outgoing_messages,
preallocated->queue_link);
connection,
connection->n_outgoing);
- if (dbus_message_get_serial (message) == 0)
- {
- serial = _dbus_connection_get_next_client_serial (connection);
- dbus_message_set_serial (message, serial);
- if (client_serial)
- *client_serial = serial;
- }
- else
- {
- if (client_serial)
- *client_serial = dbus_message_get_serial (message);
- }
-
- _dbus_verbose ("Message %p serial is %u\n",
- message, dbus_message_get_serial (message));
-
- dbus_message_lock (message);
-
/* Now we need to run an iteration to hopefully just write the messages
* out immediately, and otherwise get them queued up
*/
_dbus_sleep_milliseconds (1000);
}
-static DBusMessage *
-generate_local_error_message (dbus_uint32_t serial,
- char *error_name,
- char *error_msg)
-{
- DBusMessage *message;
- message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
- if (!message)
- goto out;
-
- if (!dbus_message_set_error_name (message, error_name))
- {
- dbus_message_unref (message);
- message = NULL;
- goto out;
- }
-
- dbus_message_set_no_reply (message, TRUE);
-
- if (!dbus_message_set_reply_serial (message,
- serial))
- {
- dbus_message_unref (message);
- message = NULL;
- goto out;
- }
-
- if (error_msg != NULL)
- {
- DBusMessageIter iter;
-
- dbus_message_iter_init_append (message, &iter);
- if (!dbus_message_iter_append_basic (&iter,
- DBUS_TYPE_STRING,
- &error_msg))
- {
- dbus_message_unref (message);
- message = NULL;
- goto out;
- }
- }
-
- out:
- return message;
-}
-
/*
* Peek the incoming queue to see if we got reply for a specific serial
*/
{
DBusMessage *error_msg;
- error_msg = generate_local_error_message (client_serial,
- DBUS_ERROR_DISCONNECTED,
- "Connection was disconnected before a reply was received");
+ error_msg = _dbus_generate_local_error_message (client_serial,
+ DBUS_ERROR_DISCONNECTED,
+ "Connection was disconnected before a reply was received");
/* on OOM error_msg is set to NULL */
complete_pending_call_and_unlock (connection, pending, error_msg);
return res;
}
+dbus_bool_t
+_dbus_connection_is_kdbus (DBusConnection *connection)
+{
+ const char *address = _dbus_transport_get_address (connection->transport);
+
+ if (NULL == connection)
+ return FALSE;
+
+ if(address != NULL && !strncmp(address, DBUS_ADDRESS_KDBUS, 7))
+ return TRUE;
+
+ return FALSE;
+}
+
+
/**
* Gets whether the connection is not authenticated as a specific
* user. If the connection is not authenticated, this function
return retval;
}
+/**
+ *
+ * Getter for number of messages in incoming queue.
+ * Useful for sending reply to self (see kdbus_do_iteration)
+ */
+int
+_dbus_connection_get_n_incoming (DBusConnection *connection)
+{
+ return connection->n_incoming;
+}
/**
* Gets the UNIX user ID of the connection if known. Returns #TRUE if
dbus_connection_get_unix_user (DBusConnection *connection,
unsigned long *uid)
{
- dbus_bool_t result;
+ dbus_bool_t result = FALSE;
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (uid != NULL, FALSE);
CONNECTION_LOCK (connection);
- if (!_dbus_transport_try_to_authenticate (connection->transport))
- result = FALSE;
+ if (_dbus_connection_is_kdbus (connection))
+ {
+ const char *unique_name = dbus_bus_get_unique_name (connection);
+ if (unique_name != NULL)
+ result = kdbus_connection_get_unix_user (connection->transport,
+ unique_name, uid, NULL);
+ else
+ {
+ _dbus_verbose("Unable to get bus unique name");
+ result = FALSE;
+ }
+ }
else
- result = _dbus_transport_get_unix_user (connection->transport,
- uid);
+ {
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
+ result = FALSE;
+ else
+ result = _dbus_transport_get_unix_user (connection->transport,
+ uid);
+ }
#ifdef DBUS_WIN
_dbus_assert (!result);
dbus_connection_get_unix_process_id (DBusConnection *connection,
unsigned long *pid)
{
- dbus_bool_t result;
+ dbus_bool_t result = FALSE;
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (pid != NULL, FALSE);
CONNECTION_LOCK (connection);
- if (!_dbus_transport_try_to_authenticate (connection->transport))
- result = FALSE;
+ if (_dbus_connection_is_kdbus (connection))
+ {
+ const char *unique_name = dbus_bus_get_unique_name (connection);
+ if (unique_name != NULL)
+ result = kdbus_connection_get_unix_process_id (connection->transport,
+ unique_name, pid, NULL);
+ else
+ {
+ _dbus_verbose("Unable to get bus unique name.");
+ result = FALSE;
+ }
+ }
else
- result = _dbus_transport_get_unix_process_id (connection->transport,
- pid);
+ {
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
+ result = FALSE;
+ else
+ result = _dbus_transport_get_unix_process_id (connection->transport,
+ pid);
+ }
CONNECTION_UNLOCK (connection);
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-marshal-gvariant.c Marshalling routines for GVariant protocol
+ *
+ * Copyright (C) 2015 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <config.h>
+#include "dbus-internals.h"
+#include "dbus-marshal-gvariant.h"
+#include "dbus-protocol-gvariant.h"
+#include "dbus-marshal-basic.h"
+#include "dbus-message-private.h"
+#include "dbus-signature.h"
+#include "dbus-connection-internal.h"
+#include <endian.h>
+
+/** Static #DBusString containing the signature of a message header */
+_DBUS_STRING_DEFINE_STATIC(_dbus_header_gvariant_signature_str, DBUS_HEADER_GVARIANT_SIGNATURE);
+
+#define FIELD_ID_SIZE sizeof(dbus_uint64_t)
+
+const DBusString *
+_dbus_get_gvariant_header_signature_str (void)
+{
+ return &_dbus_header_gvariant_signature_str;
+}
+
+static dbus_bool_t
+append_sized_value (DBusString *str,
+ size_t value,
+ size_t value_size)
+{
+ /* always write as little endian */
+ int i;
+ for (i = 0; i < value_size; i++)
+ {
+ size_t move = 8 * i;
+ size_t mask = 0xFF << move;
+ if (!_dbus_string_append_byte(str, (value & mask) >> move))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+#define MAX_OFFSET_SIZE 8
+#define MAX_VALUE_FOR_OFFSET_SIZE(o) ((1ULL<<(8*(o)))-1)
+
+/* taken from systemd */
+static size_t
+bus_gvariant_determine_word_size(size_t sz, size_t extra)
+{
+ if (sz + extra <= 0xFF)
+ return 1;
+ else if (sz + extra*2 <= 0xFFFF)
+ return 2;
+ else if (sz + extra*4 <= 0xFFFFFFFF)
+ return 4;
+ else
+ return 8;
+}
+
+/* taken from systemd */
+static size_t
+bus_gvariant_read_word_le (const void *p, size_t sz)
+{
+ union {
+ uint16_t u16;
+ uint32_t u32;
+ uint64_t u64;
+ } x;
+
+ // FIXME
+// assert(p);
+
+ if (sz == 1)
+ return *(uint8_t*) p;
+
+ memcpy(&x, p, sz);
+
+ if (sz == 2)
+ return le16toh(x.u16);
+ else if (sz == 4)
+ return le32toh(x.u32);
+ else if (sz == 8)
+ return le64toh(x.u64);
+ return 0;
+}
+
+static const char *
+get_header_const_array (DBusHeader *header)
+{
+ return _dbus_string_get_const_data (&header->data) + FIRST_GVARIANT_FIELD_OFFSET;
+}
+
+static size_t
+get_header_array_size (DBusHeader *header)
+{
+ return _dbus_string_get_length (&header->data) - FIRST_GVARIANT_FIELD_OFFSET - header->padding;
+}
+
+static dbus_bool_t
+append_offsets (DBusString *str,
+ size_t *fields_offsets,
+ size_t n_fields_offsets)
+{
+ int i;
+ size_t array_size = _dbus_string_get_length (str) - FIRST_GVARIANT_FIELD_OFFSET;
+ size_t offset_size = bus_gvariant_determine_word_size (array_size, n_fields_offsets);
+
+ for (i = 0; i < n_fields_offsets; i++)
+ {
+ if (!append_sized_value (str, fields_offsets[i], offset_size))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static dbus_bool_t
+append_field_string (DBusString *str,
+ dbus_uint64_t field,
+ const char *value,
+ char type,
+ size_t *fields_offsets,
+ size_t *n_fields_offsets)
+{
+ dbus_bool_t res = TRUE;
+ if (value != NULL)
+ {
+ res = res && _dbus_string_align_length(str, 8);
+ res = res && append_sized_value(str, field, FIELD_ID_SIZE);
+ res = res && _dbus_string_append_len(str, value, strlen(value)+1);
+ res = res && _dbus_string_append_byte(str, 0); /* variant value-signature separator */
+ res = res && _dbus_string_append_byte(str, type);
+ fields_offsets[(*n_fields_offsets)++] = _dbus_string_get_length(str) - FIRST_GVARIANT_FIELD_OFFSET;
+ }
+ return res;
+}
+
+static dbus_bool_t
+append_field_uint64 (DBusString *str,
+ dbus_uint64_t field,
+ dbus_uint64_t value,
+ size_t *fields_offsets,
+ size_t *n_fields_offsets)
+{
+ dbus_bool_t res = TRUE;
+ res = res && _dbus_string_align_length(str, 8);
+ res = res && append_sized_value(str, field, FIELD_ID_SIZE);
+ res = res && append_sized_value(str, value, 8);
+ res = res && _dbus_string_append_byte(str, 0); /* variant value-signature separator */
+ res = res && _dbus_string_append_byte(str, DBUS_TYPE_UINT64);
+ fields_offsets[(*n_fields_offsets)++] = _dbus_string_get_length(str) - FIRST_GVARIANT_FIELD_OFFSET;
+ return res;
+}
+
+static dbus_bool_t
+append_field_uint32 (DBusString *str,
+ dbus_uint64_t field,
+ dbus_uint32_t value,
+ size_t *fields_offsets,
+ size_t *n_fields_offsets)
+{
+ dbus_bool_t res = TRUE;
+ res = res && _dbus_string_align_length(str, 8);
+ res = res && append_sized_value(str, field, FIELD_ID_SIZE);
+ res = res && append_sized_value(str, value, 4);
+ res = res && _dbus_string_append_byte(str, 0); /* variant value-signature separator */
+ res = res && _dbus_string_append_byte(str, DBUS_TYPE_UINT32);
+
+ fields_offsets[(*n_fields_offsets)++] = _dbus_string_get_length(str) - FIRST_GVARIANT_FIELD_OFFSET;
+ return res;
+}
+
+static void
+_dbus_header_toggle_gvariant (DBusHeader *header, dbus_bool_t gvariant)
+{
+#ifdef ENABLE_KDBUS_TRANSPORT
+ header->protocol_version = gvariant ? DBUS_PROTOCOL_VERSION_GVARIANT : DBUS_MAJOR_PROTOCOL_VERSION;
+#endif
+}
+
+static const char *
+get_next_field_address (const char *array_buffer, size_t offset)
+{
+ return array_buffer + _DBUS_ALIGN_VALUE(offset, 8);
+}
+
+static dbus_uint64_t
+get_field_after (const char *array_buffer, size_t offset)
+{
+ return *(dbus_uint64_t*)(get_next_field_address(array_buffer, offset));
+}
+
+static void
+_dbus_header_fill_cache (DBusHeader *header,
+ size_t *fields_offsets,
+ size_t n_fields_offsets)
+{
+ const char *array_buffer = get_header_const_array (header);
+ int i;
+
+ if (get_header_array_size (header) > 0)
+ {
+ header->fields[get_field_after (array_buffer, 0)].value_pos = FIELD_ID_SIZE + FIRST_GVARIANT_FIELD_OFFSET;
+ for (i=0; i < n_fields_offsets-1; i++)
+ {
+ dbus_uint64_t field = get_field_after (array_buffer, fields_offsets[i]);
+ header->fields[field].value_pos = _DBUS_ALIGN_VALUE(fields_offsets[i],8) +
+ FIELD_ID_SIZE + FIRST_GVARIANT_FIELD_OFFSET;
+ }
+ }
+}
+
+static dbus_bool_t
+correct_header_padding (DBusHeader *header)
+{
+ int unpadded_len = _dbus_string_get_length (&header->data);
+ if (!_dbus_string_align_length (&header->data, 8))
+ return FALSE;
+
+ header->padding = _dbus_string_get_length (&header->data) - unpadded_len;
+ return TRUE;
+}
+
+dbus_bool_t
+_dbus_header_gvariant_create (DBusHeader *header,
+ int byte_order,
+ int type,
+ const char *destination,
+ const char *path,
+ const char *interface,
+ const char *member,
+ const char *error_name)
+{
+ size_t fields_offsets[DBUS_HEADER_FIELD_LAST];
+ size_t n_fields_offsets = 0;
+ dbus_bool_t res = TRUE;
+
+ _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
+ byte_order == DBUS_BIG_ENDIAN);
+ _dbus_assert (((interface || type != DBUS_MESSAGE_TYPE_SIGNAL) && member) ||
+ (error_name) ||
+ !(interface || member || error_name));
+ _dbus_assert (_dbus_string_get_length (&header->data) == 0);
+
+ _dbus_header_toggle_gvariant (header, TRUE);
+
+ res = res && _dbus_string_append_byte (&header->data, byte_order);
+ res = res && _dbus_string_append_byte (&header->data, type);
+ res = res && _dbus_string_append_byte (&header->data, 0); /* flags */
+ res = res && _dbus_string_append_byte (&header->data, DBUS_PROTOCOL_VERSION_GVARIANT);
+ res = res && append_sized_value (&header->data, 0, sizeof(dbus_uint32_t)); /* reserved */
+ res = res && append_sized_value (&header->data, 0, sizeof(dbus_uint64_t)); /* cookie */
+ /* array of fields */
+ res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_PATH, path, DBUS_TYPE_OBJECT_PATH,
+ fields_offsets, &n_fields_offsets);
+ res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_DESTINATION, destination, DBUS_TYPE_STRING,
+ fields_offsets, &n_fields_offsets);
+ res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_INTERFACE, interface, DBUS_TYPE_STRING,
+ fields_offsets, &n_fields_offsets);
+ res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_MEMBER, member, DBUS_TYPE_STRING,
+ fields_offsets, &n_fields_offsets);
+ res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_ERROR_NAME, error_name, DBUS_TYPE_STRING,
+ fields_offsets, &n_fields_offsets);
+ res = res && append_offsets (&header->data, fields_offsets, n_fields_offsets);
+
+ _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets);
+ res = res && correct_header_padding (header);
+
+ return res;
+}
+
+static dbus_bool_t
+marshal_gvariant_string (DBusString *str,
+ int insert_at,
+ const char *value,
+ int *pos_after,
+ dbus_bool_t with_nul)
+{
+ DBusString value_str;
+ size_t value_len = strlen(value);
+
+ if (with_nul)
+ value_len++;
+
+ _dbus_string_init_const_len (&value_str, value, value_len);
+ if (!_dbus_string_copy_len (&value_str, 0, value_len, str, insert_at))
+ {
+ return FALSE;
+ }
+
+ if (pos_after)
+ *pos_after = insert_at + value_len;
+
+ return TRUE;
+}
+
+dbus_bool_t
+_dbus_marshal_write_gvariant_basic (DBusString *str,
+ int insert_at,
+ int type,
+ const void *value,
+ int byte_order,
+ int *pos_after)
+{
+ const DBusBasicValue *vp;
+ _dbus_assert (dbus_type_is_basic (type));
+
+ vp = value;
+
+ switch (type)
+ {
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ return marshal_gvariant_string (str, insert_at, vp->str, pos_after, TRUE);
+ case DBUS_TYPE_BOOLEAN:
+ if (pos_after)
+ (*pos_after)++;
+ return _dbus_string_insert_byte (str, insert_at, vp->u32 != FALSE);
+ default:
+ return _dbus_marshal_write_basic (str, insert_at, type, value, byte_order, pos_after);
+ }
+}
+
+void
+_dbus_marshal_read_gvariant_basic (const DBusString *str,
+ int pos,
+ int type,
+ void *value,
+ int byte_order,
+ int *new_pos)
+{
+ const char *str_data;
+
+ _dbus_assert (dbus_type_is_basic (type));
+
+ str_data = _dbus_string_get_const_data (str);
+ switch (type)
+ {
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ {
+ volatile char **vp = value;
+ *vp = (char*) str_data + pos;
+ pos += strlen (str_data+pos)+1;
+ }
+ break;
+ case DBUS_TYPE_BOOLEAN:
+ {
+ volatile dbus_bool_t *vp = value;
+ *vp = (dbus_bool_t) _dbus_string_get_byte (str, pos);
+ (pos)++;
+ }
+ break;
+ default:
+ _dbus_marshal_read_basic (str, pos, type, value, byte_order, new_pos);
+ break;
+ }
+
+ if (new_pos)
+ *new_pos = pos;
+}
+
+static void
+get_offsets (const char *buffer, size_t container_size,
+ size_t *fields_offsets, size_t *n_fields_offsets,
+ size_t *offset_size)
+{
+ *offset_size = bus_gvariant_determine_word_size (container_size, 0);
+
+ if (0 < container_size && 0 < *offset_size)
+ {
+ size_t last_offset_position = container_size - (*offset_size);
+ size_t last_offset = bus_gvariant_read_word_le (buffer + last_offset_position,
+ (*offset_size));
+ int i;
+
+ *n_fields_offsets = (container_size - last_offset) / (*offset_size);
+ fields_offsets[(*n_fields_offsets)-1] = last_offset;
+ for (i = 0; i < (*n_fields_offsets)-1; i++)
+ {
+ fields_offsets[i] = bus_gvariant_read_word_le (buffer + last_offset + i*(*offset_size),
+ (*offset_size));
+ }
+ }
+}
+
+static int
+find_field (int field, const char *array_buffer, size_t *fields_offsets, size_t n_fields_offsets,
+ size_t *field_offset)
+{
+ /* last_offset points to the offsets array, beyond the last element of the array container */
+ size_t last_offset = fields_offsets[n_fields_offsets-1];
+ int i = 0;
+ size_t next_offset = 0;
+
+ while ( next_offset < last_offset && get_field_after (array_buffer, next_offset) != field)
+ {
+ next_offset = fields_offsets[i];
+ i++;
+ }
+ if (next_offset < last_offset)
+ {
+ *field_offset = next_offset;
+ return i;
+ }
+ return -1;
+}
+
+dbus_bool_t
+_dbus_header_gvariant_delete_field (DBusHeader *header,
+ int field)
+{
+ size_t fields_offsets[DBUS_HEADER_FIELD_LAST];
+ size_t n_fields_offsets = 0;
+ size_t offset_size = 0;
+ const char *array_buffer;
+
+ _dbus_assert(field <= DBUS_HEADER_FIELD_LAST);
+
+ array_buffer = get_header_const_array (header);
+
+ get_offsets (array_buffer,
+ get_header_array_size (header),
+ fields_offsets, &n_fields_offsets, &offset_size );
+
+ if (0 < n_fields_offsets)
+ {
+ /* check if the field is already in the header */
+ size_t field_offset;
+ int field_index = find_field (field, array_buffer, fields_offsets, n_fields_offsets, &field_offset);
+
+ /* prepare for changing - remove array offsets and offsets */
+ _dbus_string_shorten (&header->data, n_fields_offsets*offset_size + header->padding);
+
+ if (field_index >= 0)
+ {
+ /* field exists */
+ size_t field_len = 0;
+ size_t field_start = 0;
+ /* let's remove aligned block of the field, along with padding */
+ if (field_index == 0)
+ {
+ field_len = _DBUS_ALIGN_VALUE (fields_offsets[0],8);
+ }
+ else
+ {
+ field_len = _DBUS_ALIGN_VALUE (fields_offsets[field_index],8) -
+ _DBUS_ALIGN_VALUE (fields_offsets[field_index-1],8);
+ }
+
+ field_start = FIRST_GVARIANT_FIELD_OFFSET + _DBUS_ALIGN_VALUE (field_offset, 8);
+
+ /* if this is the last field, then there is no padding at the end */
+ if (field_start + field_len > _dbus_string_get_length (&header->data))
+ {
+ field_len = _dbus_string_get_length (&header->data) - field_start;
+ }
+
+ /* remove the field */
+ _dbus_string_delete (&header->data, field_start, field_len);
+ header->fields[field].value_pos = _DBUS_HEADER_FIELD_VALUE_NONEXISTENT;
+ /* and update offsets */
+ for (; field_index < n_fields_offsets-1; field_index++)
+ {
+ fields_offsets[field_index] = fields_offsets[field_index+1]-field_len;
+ }
+ n_fields_offsets--;
+
+ /* remove padding from now-last field */
+ _dbus_string_shorten (&header->data,
+ _dbus_string_get_length(&header->data) -
+ (FIRST_GVARIANT_FIELD_OFFSET + fields_offsets[n_fields_offsets-1]));
+ header->padding = 0;
+ }
+ }
+
+ /* It seems impossible for append_offsets() and correct_header_padding() to fail,
+ because space for offsets was already allocated */
+ if (!append_offsets(&header->data, fields_offsets, n_fields_offsets))
+ return FALSE;
+ _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets);
+ if (!correct_header_padding (header))
+ return FALSE;
+
+ return TRUE;
+}
+
+dbus_bool_t
+_dbus_header_set_field_basic_gvariant (DBusHeader *header,
+ int field,
+ int type,
+ const void *value)
+{
+ size_t fields_offsets[DBUS_HEADER_FIELD_LAST];
+ size_t n_fields_offsets = 0;
+ dbus_bool_t result = TRUE;
+ const DBusBasicValue *vp = value;
+ size_t offset_size = 0;
+ const char *array_buffer;
+
+ _dbus_assert(field != DBUS_HEADER_FIELD_INVALID);
+ _dbus_assert(field <= DBUS_HEADER_FIELD_LAST);
+
+ array_buffer = get_header_const_array (header);
+
+ result = result && _dbus_header_gvariant_delete_field (header, field);
+
+ /* now, we are sure that there is no such field (anymore) - so, simply append */
+
+ get_offsets (array_buffer,
+ get_header_array_size (header),
+ fields_offsets, &n_fields_offsets, &offset_size );
+
+ /* prepare for changing - remove array offsets and padding */
+ _dbus_string_shorten (&header->data, n_fields_offsets*offset_size + header->padding);
+
+ switch (type)
+ {
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ result = result && append_field_string (&header->data, field, vp->str, type,
+ fields_offsets, &n_fields_offsets);
+ break;
+ case DBUS_TYPE_UINT32:
+ result = result && append_field_uint32 (&header->data, field, vp->u32,
+ fields_offsets, &n_fields_offsets);
+ break;
+ case DBUS_TYPE_UINT64:
+ append_field_uint64 (&header->data, field, vp->u64,
+ fields_offsets, &n_fields_offsets);
+ result = TRUE;
+ break;
+ default:
+ _dbus_assert_not_reached("Not a basic type");
+ result = FALSE;
+ break;
+ }
+
+ result = result && append_offsets(&header->data, fields_offsets, n_fields_offsets);
+ _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets);
+ result = result && correct_header_padding (header);
+
+ return result;
+}
+
+dbus_bool_t
+_dbus_header_get_field_basic_gvariant (DBusHeader *header,
+ int field,
+ int type,
+ void *value)
+{
+ size_t fields_offsets[DBUS_HEADER_FIELD_LAST];
+ size_t n_fields_offsets = 0;
+ dbus_bool_t result = FALSE;
+ DBusBasicValue *vp = value;
+ size_t offset_size = 0;
+ const char *array_buffer;
+
+ _dbus_assert(field != DBUS_HEADER_FIELD_INVALID);
+ _dbus_assert(field <= DBUS_HEADER_FIELD_LAST);
+
+ array_buffer = get_header_const_array (header);
+
+ get_offsets( array_buffer,
+ get_header_array_size (header),
+ fields_offsets, &n_fields_offsets, &offset_size );
+
+ if (0 < n_fields_offsets)
+ {
+ /* check if the field is already in the header */
+ size_t field_offset;
+ int field_index = find_field (field, array_buffer, fields_offsets, n_fields_offsets, &field_offset);
+ if (0 <= field_index)
+ {
+ /* field found, get value */
+ const void *field_begin = array_buffer + _DBUS_ALIGN_VALUE(field_offset,8) + FIELD_ID_SIZE;
+ dbus_uint32_t byte_order = _dbus_header_get_byte_order (header);
+
+ switch (type)
+ {
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ {
+ vp->str = (char *)field_begin;
+ }
+ break;
+ case DBUS_TYPE_UINT32:
+ {
+ vp->u32 = *(const dbus_uint32_t *)field_begin;
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ vp->u32 = DBUS_UINT32_SWAP_LE_BE (vp->u32);
+ }
+ break;
+ case DBUS_TYPE_UINT64:
+ {
+ vp->u64 = *(const dbus_uint64_t *)field_begin;
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ vp->u64 = DBUS_UINT64_SWAP_LE_BE (vp->u64);
+ }
+ break;
+ default:
+ _dbus_assert_not_reached("Not a basic type");
+ break;
+ }
+
+ result = TRUE;
+ }
+ }
+ return result;
+}
+
+void
+_dbus_marshal_skip_gvariant_basic (const DBusString *str,
+ int type,
+ int byte_order,
+ int *pos)
+{
+ switch (type)
+ {
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ /* FIXME - this will require redesign... size should come from upper container */
+ *pos += strlen (_dbus_string_get_const_data (str) + *pos) + 1; /* length plus nul */
+ break;
+ case DBUS_TYPE_BOOLEAN:
+ (*pos)++;
+ break;
+ default:
+ _dbus_marshal_skip_basic (str, type, byte_order, pos);
+ break;
+ }
+}
+
+dbus_bool_t
+_dbus_header_load_gvariant (DBusHeader *header,
+ DBusTypeReader *reader,
+ DBusValidity *validity)
+{
+ size_t fields_offsets[DBUS_HEADER_FIELD_LAST];
+ size_t n_fields_offsets = 0;
+ size_t offset_size = 0;
+ const char *array_buffer = get_header_const_array (header);
+
+ get_offsets( array_buffer,
+ get_header_array_size (header),
+ fields_offsets, &n_fields_offsets, &offset_size );
+
+ _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets);
+ return TRUE;
+}
+
+dbus_bool_t
+_dbus_gvariant_raw_get_lengths (const DBusString *str,
+ dbus_uint32_t *fields_array_len_unsigned,
+ dbus_uint32_t *body_len_unsigned,
+ DBusValidity *validity)
+{
+ size_t message_len = _dbus_string_get_length (str);
+ size_t body_offsets_size = bus_gvariant_determine_word_size (message_len, 0);
+ const char *message_ptr = _dbus_string_get_const_data (str);
+ /* so, the offset of end of fields is written at offset str->len - body_offsets_size */
+ size_t end_of_fields = bus_gvariant_read_word_le (message_ptr + message_len - body_offsets_size,
+ body_offsets_size);
+ *fields_array_len_unsigned = end_of_fields - FIRST_GVARIANT_FIELD_OFFSET;
+
+ *body_len_unsigned = message_len - _DBUS_ALIGN_VALUE (end_of_fields, 8);
+ return TRUE;
+}
+
+DBusValidity
+_dbus_validate_gvariant_body_with_reason (const DBusString *expected_signature,
+ int expected_signature_start,
+ int byte_order,
+ int *bytes_remaining,
+ const DBusString *value_str,
+ int value_pos,
+ int len)
+{
+ /* FIXME stub */
+ if (bytes_remaining)
+ *bytes_remaining = 0;
+ return DBUS_VALID;
+}
+
+dbus_bool_t
+_dbus_message_gvariant_get_signature (DBusMessage *message,
+ const DBusString **type_str_p,
+ int *type_pos_p,
+ int *type_str_len)
+{
+ size_t body_len = _dbus_string_get_length (&message->body);
+ size_t message_len = _dbus_string_get_length (&message->header.data) + body_len;
+ size_t body_offsets_size = bus_gvariant_determine_word_size (message_len, 0);
+ const char *body_ptr = _dbus_string_get_const_data (&message->body);
+ const char *sig_end_ptr = body_ptr + body_len - body_offsets_size;
+ const char *sig_ptr = sig_end_ptr - 1;
+
+ while (sig_ptr >= body_ptr && (*sig_ptr) != 0)
+ {
+ sig_ptr--;
+ }
+
+ if (sig_ptr < body_ptr)
+ return FALSE;
+
+ if (type_str_p != NULL)
+ *type_str_p = &message->body;
+ *type_pos_p = sig_ptr - body_ptr + 1;
+ *type_str_len = sig_end_ptr - sig_ptr - 1;
+
+ return TRUE;
+}
+
+dbus_bool_t
+_dbus_message_append_body_offset (DBusMessage *message)
+{
+ size_t body_len = _dbus_string_get_length (&message->body);
+ size_t end_of_fields_offset = _dbus_string_get_length (&message->header.data) - message->header.padding;
+ size_t message_len = _dbus_string_get_length (&message->header.data) + body_len;
+ size_t body_offsets_size = bus_gvariant_determine_word_size (message_len, 1);
+
+ return append_sized_value (&message->body, end_of_fields_offset, body_offsets_size);
+}
+
+dbus_bool_t
+_dbus_message_gvariant_add_signature (DBusMessage *message,
+ const DBusString *type_str)
+{
+ dbus_bool_t res = _dbus_string_append_byte (&message->body, 0);
+ res = res && _dbus_string_append_byte (&message->body, '(');
+ res = res && marshal_gvariant_string (&message->body, _dbus_string_get_length (&message->body),
+ _dbus_string_get_const_data (type_str), NULL, FALSE);
+ res = res && _dbus_string_append_byte (&message->body, ')');
+ return res;
+}
+
+dbus_bool_t
+_dbus_message_gvariant_remove_body_offset (DBusMessage *message)
+{
+ size_t offset_size = bus_gvariant_determine_word_size (_dbus_string_get_length (&message->header.data) +
+ _dbus_string_get_length (&message->body),
+ 0);
+ _dbus_string_shorten (&message->body, offset_size);
+ return TRUE;
+}
+
+dbus_bool_t
+_dbus_message_finalize_gvariant (DBusMessage *message, dbus_bool_t remove_signature_from_header)
+{
+ DBusString str;
+ const DBusString *type_str;
+ int type_pos;
+ dbus_bool_t fieldSignaturePresent;
+ dbus_bool_t res = TRUE;
+
+ _dbus_assert (!message->locked);
+
+ if (message->header.protocol_version != DBUS_PROTOCOL_VERSION_GVARIANT)
+ return TRUE;
+
+ fieldSignaturePresent = _dbus_header_get_field_raw (&message->header,
+ DBUS_HEADER_FIELD_SIGNATURE,
+ &type_str,
+ &type_pos);
+ if (fieldSignaturePresent)
+ {
+ /* if there is signature field, then we need to move this signature to body,
+ * and delete the field
+ */
+ const char *sig_ptr = _dbus_string_get_const_data (type_str) + type_pos;
+ _dbus_string_init_const (&str, sig_ptr);
+ }
+ else
+ {
+ /* If there is no signature field, then the body is empty.
+ * However, we need to add signature anyway, because body is a variant.
+ */
+ _dbus_string_init_const (&str, "");
+ type_str = &str;
+ type_pos = 0;
+ /* Let's set the body also */
+ _dbus_string_set_length (&message->body, 0);
+ _dbus_string_append_byte (&message->body, 0);
+ }
+
+ res = res && _dbus_message_gvariant_add_signature (message, &str);
+
+ if (res && fieldSignaturePresent && remove_signature_from_header)
+ res = res && _dbus_header_gvariant_delete_field (&message->header, DBUS_HEADER_FIELD_SIGNATURE);
+
+ res = res && _dbus_message_append_body_offset (message);
+
+ return res;
+}
+
+/* returns length of the body inside the outermost variant
+ * that is, without offset and signature from the end of messages
+ */
+static size_t
+_dbus_message_gvariant_get_body_length (DBusMessage *message)
+{
+ size_t body_len = _dbus_string_get_length (&message->body);
+ size_t message_len = body_len + _dbus_string_get_length (&message->header.data);
+ body_len -= bus_gvariant_determine_word_size (message_len , 0);
+
+ while (body_len > 0 && _dbus_string_get_byte (&message->body, body_len) != 0)
+ body_len--;
+
+ return body_len;
+}
+
+static inline int
+get_max (int a, int b)
+{
+ return (a>b) ? a : b;
+}
+
+static int
+update_size (int current_size, int size_of_element, int *alignment, int new_alignment)
+{
+ *alignment = get_max (*alignment, new_alignment);
+ current_size = _DBUS_ALIGN_VALUE (current_size, *alignment);
+ return current_size + size_of_element;
+}
+
+static int
+_dbus_reader_get_signature_fixed_size (const DBusString *signature, int *pos, int *alignment)
+{
+ int res = 0;
+ int depth = 0;
+ int current_alignment = 1;
+ dbus_bool_t variable = FALSE;
+
+ char c = _dbus_string_get_byte (signature, *pos);
+ if (c == DBUS_STRUCT_BEGIN_CHAR || c == DBUS_DICT_ENTRY_BEGIN_CHAR)
+ {
+ depth = 1;
+ (*pos)++;
+ }
+
+ do {
+ switch (_dbus_string_get_byte (signature, *pos))
+ {
+ case DBUS_TYPE_BYTE:
+ case DBUS_TYPE_BOOLEAN:
+ res += 1;
+ break;
+ case DBUS_TYPE_INT16:
+ case DBUS_TYPE_UINT16:
+ res = update_size (res, 2, ¤t_alignment, 2);
+ break;
+ case DBUS_TYPE_INT32:
+ case DBUS_TYPE_UINT32:
+ case DBUS_TYPE_UNIX_FD:
+ res = update_size (res, 4, ¤t_alignment, 4);
+ break;
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ case DBUS_TYPE_DOUBLE:
+ res = update_size (res, 8, ¤t_alignment, 8);
+ break;
+ case DBUS_STRUCT_END_CHAR:
+ case DBUS_DICT_ENTRY_END_CHAR:
+ depth--;
+ break;
+ case DBUS_STRUCT_BEGIN_CHAR:
+ case DBUS_DICT_ENTRY_BEGIN_CHAR:
+ {
+ int alignment_recursive;
+ int res_recursive = _dbus_reader_get_signature_fixed_size (signature, pos, &alignment_recursive);
+ if (res_recursive == 0)
+ variable = TRUE; /* variable size detected */
+
+ /* we need to update at least alignment */
+ res = update_size (res, res_recursive, ¤t_alignment, alignment_recursive);
+ }
+ break;
+ case DBUS_TYPE_VARIANT:
+ current_alignment = 8;
+ variable = TRUE;
+ break;
+ case DBUS_TYPE_ARRAY:
+ {
+ int alignment_recursive;
+ int recursive_pos = *pos + 1;
+ int res_recursive = _dbus_reader_get_signature_fixed_size (signature, &recursive_pos, &alignment_recursive);
+
+ variable = TRUE; /* variable size detected */
+
+ /* we need to update alignment */
+ res = update_size (res, res_recursive, ¤t_alignment, alignment_recursive);
+
+ /* and update position */
+ *pos = recursive_pos - 1;
+ }
+ break;
+ default:
+ variable = TRUE; /* variable size detected */
+ }
+ (*pos)++;
+ } while (depth > 0);
+
+ /* we want to point it to the last character, to allow upper instance to skip it */
+ (*pos)--;
+
+ if (alignment != NULL)
+ *alignment = current_alignment;
+
+ return variable ? 0 : res;
+}
+
+int
+_dbus_reader_get_type_fixed_size (DBusTypeReader *reader, int *alignment)
+{
+ int pos = reader->type_pos;
+ return _dbus_reader_get_signature_fixed_size (reader->type_str, &pos, alignment);
+}
+
+int
+_dbus_type_gvariant_get_fixed_size (const DBusString *type_str, int type_pos, int *alignment)
+{
+ return _dbus_reader_get_signature_fixed_size (type_str, &type_pos, alignment);
+}
+
+/* This is for structs and dict entries.
+ * Counts variable elements inside a container.
+ * This is equal to number of offsets embedded into the container.
+ */
+int
+_dbus_reader_count_offsets (const DBusTypeReader *reader)
+{
+ DBusTypeReader r;
+ int variables = 0;
+ dbus_bool_t prev_is_variable = FALSE;
+ int current_type;
+ int ending_char;
+
+ /* if signature is not empty, it must be after initial parenthesis */
+ /* empty signature has length 1 - only nul byte */
+ _dbus_assert (reader->type_pos > 0);
+
+ _dbus_type_reader_init_types_only (&r,
+ reader->type_str,
+ reader->type_pos);
+ r.gvariant = TRUE;
+ r.klass = reader->klass;
+
+ /* Check what container we're in */
+ switch (_dbus_string_get_byte (r.type_str, r.type_pos-1))
+ {
+ case DBUS_STRUCT_BEGIN_CHAR:
+ ending_char = DBUS_STRUCT_END_CHAR;
+ break;
+ case DBUS_DICT_ENTRY_BEGIN_CHAR:
+ ending_char = DBUS_DICT_ENTRY_END_CHAR;
+ break;
+ default:
+ _dbus_assert_not_reached ("function must be called inside structs or dict entries");
+ break;
+ }
+ r.finished = (_dbus_string_get_byte (r.type_str, r.type_pos) == ending_char);
+
+ while ((current_type = _dbus_type_reader_get_current_type (&r)) != DBUS_TYPE_INVALID)
+ {
+ int size = _dbus_reader_get_type_fixed_size (&r, NULL);
+ if (prev_is_variable)
+ variables++;
+ prev_is_variable = (size == 0);
+ _dbus_type_signature_next (_dbus_string_get_const_data(r.type_str), &r.type_pos);
+ r.finished = (_dbus_string_get_byte (r.type_str, r.type_pos) == ending_char);
+ }
+ return variables;
+}
+
+size_t
+_dbus_reader_get_offset_of_end_of_variable (DBusTypeReader *reader)
+{
+ if (reader->is_variant)
+ {
+ /* variant has its end set to the separating 0 */
+ return reader->value_end;
+ }
+ else
+ {
+ const char *buffer = _dbus_string_get_const_data (reader->value_str) + reader->value_start;
+ size_t container_size = reader->value_end - reader->value_start;
+ size_t offset_size = bus_gvariant_determine_word_size (container_size, 0);
+ int index_from_back = reader->offsets_from_back ?
+ reader->variable_index :
+ reader->n_offsets - 1 - reader->variable_index;
+
+ if (0 < container_size && 0 <= index_from_back)
+ {
+ size_t required_offset_position = container_size - (index_from_back+1)*offset_size;
+ if (index_from_back < reader->n_offsets)
+ return reader->value_start +
+ bus_gvariant_read_word_le (buffer + required_offset_position,
+ offset_size);
+ else if (reader->offsets_from_back)
+ return reader->value_start +
+ container_size - (reader->n_offsets * offset_size); /* this is end of internal container */
+ }
+ }
+
+ return reader->value_start;
+}
+
+int
+_dbus_reader_count_array_elems (const DBusTypeReader *reader)
+{
+ const char *buffer = _dbus_string_get_const_data (reader->value_str) + reader->value_start;
+ size_t container_size = reader->value_end - reader->value_start;
+ size_t offset_size = bus_gvariant_determine_word_size (container_size, 0);
+ size_t last_offset = bus_gvariant_read_word_le (buffer + container_size - offset_size, offset_size);
+ return (container_size - last_offset) / offset_size;
+}
+
+static dbus_bool_t
+write_offset (DBusString *offsets,
+ size_t offset,
+ size_t offset_size,
+ int insert_at)
+{
+ DBusString str;
+ dbus_bool_t res = _dbus_string_init_preallocated (&str, offset_size);
+ res = res && append_sized_value (&str, offset, offset_size);
+ res = res && _dbus_string_copy_len (&str, 0, offset_size, offsets, insert_at);
+ _dbus_string_free (&str);
+ return res;
+}
+
+static dbus_bool_t
+prepend_offset (DBusString *offsets,
+ size_t offset,
+ size_t offset_size)
+{
+ return write_offset (offsets, offset, offset_size, 0);
+}
+
+static dbus_bool_t
+append_offset (DBusString *offsets,
+ size_t offset,
+ size_t offset_size)
+{
+ return write_offset (offsets, offset, offset_size, _dbus_string_get_length(offsets));
+}
+
+static dbus_bool_t
+convert_offsets (DBusString *offsets,
+ size_t old_offsets_size,
+ size_t new_offsets_size)
+{
+ char *old_offsets = NULL;
+ size_t n_offsets = _dbus_string_get_length (offsets) / old_offsets_size;
+ dbus_bool_t result = _dbus_string_steal_data (offsets, &old_offsets);
+ int i;
+
+ for (i = 0; i < n_offsets && result; i++)
+ {
+ size_t offset = bus_gvariant_read_word_le (old_offsets + i*old_offsets_size, old_offsets_size);
+ result = result && append_sized_value (offsets, offset, new_offsets_size);
+ }
+
+ dbus_free (old_offsets);
+
+ return result;
+}
+
+static size_t
+get_offsets_count (DBusString *offsets, size_t offsets_size)
+{
+ return _dbus_string_get_length (offsets) / offsets_size;
+}
+
+static dbus_bool_t
+check_offsets_for_adding (DBusTypeWriter *writer)
+{
+ size_t container_size = writer->value_pos - writer->value_start;
+ size_t n_offsets = get_offsets_count (writer->offsets,
+ writer->offsets_size);
+ size_t offsets_size = bus_gvariant_determine_word_size (container_size, n_offsets + 1);
+ if (offsets_size != writer->offsets_size)
+ {
+ if (!convert_offsets (writer->offsets, writer->offsets_size, offsets_size))
+ return FALSE;
+ writer->offsets_size = offsets_size;
+ }
+ return TRUE;
+}
+
+static dbus_bool_t
+convert_offsets_in_body (DBusTypeWriter *writer,
+ size_t new_offsets_size)
+{
+ DBusString offsets;
+ size_t n_offsets;
+ int i;
+ dbus_bool_t result = _dbus_string_init (&offsets);
+ char *old_offsets;
+
+ result = result && _dbus_string_move (writer->value_str, writer->value_pos, &offsets, 0);
+ n_offsets = _dbus_string_get_length (&offsets) / writer->offsets_size;
+ old_offsets = _dbus_string_get_data (&offsets);
+
+ for (i = 0; i < n_offsets && result; i++)
+ {
+ size_t offset = bus_gvariant_read_word_le (old_offsets + i*writer->offsets_size, writer->offsets_size);
+ result = result && append_sized_value (writer->value_str, offset, new_offsets_size);
+ }
+
+ _dbus_string_free (&offsets);
+ return result;
+}
+
+static dbus_bool_t
+check_offsets_in_body_for_adding (DBusTypeWriter *writer)
+{
+ size_t container_size = writer->value_pos - writer->value_start;
+ size_t n_offsets = (_dbus_string_get_length (writer->value_str) - writer->value_pos) / writer->offsets_size;
+ size_t offsets_size = bus_gvariant_determine_word_size (container_size, n_offsets + 1);
+ if (offsets_size != writer->offsets_size)
+ {
+ if (!convert_offsets_in_body (writer, offsets_size))
+ return FALSE;
+ writer->offsets_size = offsets_size;
+ }
+ return TRUE;
+}
+
+static dbus_bool_t
+_dbus_writer_gvariant_add_offset_with_variability (DBusTypeWriter *writer,
+ dbus_bool_t fixed)
+{
+ writer->is_fixed = writer->is_fixed && fixed;
+
+ if (writer->body_container ||
+ DBUS_TYPE_STRUCT == writer->container_type ||
+ DBUS_TYPE_DICT_ENTRY == writer->container_type)
+ {
+ if (writer->u.struct_or_dict.last_offset != 0)
+ {
+ if (writer->body_container)
+ {
+ check_offsets_in_body_for_adding (writer);
+
+ write_offset (writer->value_str,
+ writer->u.struct_or_dict.last_offset,
+ writer->offsets_size,
+ writer->value_pos);
+ }
+ else
+ {
+ check_offsets_for_adding (writer);
+
+ prepend_offset (writer->offsets,
+ writer->u.struct_or_dict.last_offset,
+ writer->offsets_size);
+ }
+ }
+ if (!fixed)
+ {
+ writer->u.struct_or_dict.last_offset = writer->value_pos - writer->value_start;
+ }
+ else
+ {
+ writer->u.struct_or_dict.last_offset = 0;
+ }
+ }
+ else if (DBUS_TYPE_ARRAY == writer->container_type)
+ {
+ if (writer->offsets_size > 0)
+ {
+ check_offsets_for_adding (writer);
+
+ if (!append_offset (writer->offsets,
+ writer->value_pos - writer->value_start,
+ writer->offsets_size))
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+static dbus_bool_t
+_dbus_writer_gvariant_add_offset (DBusTypeWriter *writer,
+ int type)
+{
+ return _dbus_writer_gvariant_add_offset_with_variability (writer, dbus_type_is_fixed (type));
+}
+
+/* this function gets only known alignments - other are 1 */
+static int
+get_alignment (int type)
+{
+ switch (type)
+ {
+ case DBUS_TYPE_INT16:
+ case DBUS_TYPE_UINT16:
+ return 2;
+ case DBUS_TYPE_INT32:
+ case DBUS_TYPE_UINT32:
+ case DBUS_TYPE_UNIX_FD:
+ return 4;
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ case DBUS_TYPE_DOUBLE:
+ case DBUS_TYPE_VARIANT:
+ return 8;
+ default:
+ break;
+ }
+ return 1;
+}
+
+static dbus_bool_t
+fix_struct_alignment_value (DBusTypeWriter *writer, int alignment)
+{
+ dbus_bool_t result = TRUE;
+ int old_alignment = writer->alignment;
+ if (old_alignment < alignment)
+ {
+ int diff = _DBUS_ALIGN_VALUE (writer->value_start, alignment) - writer->value_start;
+ result = _dbus_string_insert_bytes (writer->value_str, writer->value_start, diff, 0);
+ writer->value_start += diff;
+ writer->value_pos += diff;
+ writer->alignment = alignment;
+ }
+ return result;
+}
+
+static dbus_bool_t
+fix_struct_alignment (DBusTypeWriter *writer, int type)
+{
+ return fix_struct_alignment_value (writer, get_alignment (type));
+}
+
+dbus_bool_t
+_dbus_type_writer_gvariant_write_basic_no_typecode (DBusTypeWriter *writer,
+ int type,
+ const void *value)
+{
+ dbus_bool_t result = TRUE;
+
+ if (writer->container_type == DBUS_TYPE_STRUCT || writer->container_type == DBUS_TYPE_DICT_ENTRY)
+ result = fix_struct_alignment (writer, type);
+
+ result = result && _dbus_marshal_write_gvariant_basic (writer->value_str,
+ writer->value_pos,
+ type,
+ value,
+ writer->byte_order,
+ &writer->value_pos);
+
+ result = result && _dbus_writer_gvariant_add_offset (writer, type);
+ return result;
+}
+
+static dbus_bool_t
+write_offsets (DBusString *dest, size_t insert_at, DBusString *offsets)
+{
+ return _dbus_string_copy (offsets, 0, dest, insert_at);
+}
+
+dbus_bool_t
+_dbus_writer_unrecurse_gvariant_write (DBusTypeWriter *writer,
+ DBusTypeWriter *sub)
+{
+ dbus_bool_t result = TRUE;
+
+ if (writer->alignment < sub->alignment)
+ writer->alignment = sub->alignment;
+
+ switch (sub->container_type) {
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_DICT_ENTRY:
+ {
+ int diff;
+ int sub_len;
+
+ if (NULL != sub->offsets)
+ {
+ write_offsets (sub->value_str, sub->value_pos, sub->offsets);
+
+ _dbus_string_free (sub->offsets);
+ dbus_free (sub->offsets);
+ }
+
+ diff = _DBUS_ALIGN_VALUE (writer->value_pos, sub->alignment) - writer->value_pos;
+
+ result = _dbus_string_insert_bytes (writer->value_str, writer->value_pos, diff, 0);
+ writer->value_pos += diff;
+ sub_len = _dbus_string_get_length (sub->value_str);
+ result = result && _dbus_string_copy_len (sub->value_str, 0,
+ sub_len,
+ writer->value_str,
+ writer->value_pos);
+ writer->value_pos += sub_len;
+
+ _dbus_string_free (sub->value_str);
+ dbus_free (sub->value_str);
+
+ break;
+ }
+ case DBUS_TYPE_VARIANT:
+ {
+ int sub_type_len;
+
+ /* write separating nul byte */
+ result = _dbus_string_insert_byte (sub->value_str, sub->value_pos, 0);
+ sub->value_pos += 1;
+
+ /* write signature */
+ sub_type_len = _dbus_string_get_length (sub->type_str);
+ result = result && _dbus_string_copy_len (sub->type_str, 0,
+ sub_type_len,
+ sub->value_str,
+ sub->value_pos);
+ sub->value_pos += sub_type_len;
+
+ /* free type string allocated in writer_recurse_variant() */
+ _dbus_string_free (sub->type_str);
+ dbus_free (sub->type_str);
+
+ /* update parent's string pointer */
+ writer->value_pos = sub->value_pos;
+
+ break;
+ }
+ case DBUS_TYPE_ARRAY:
+ writer->value_pos = sub->value_pos;
+ if (NULL != sub->offsets)
+ {
+ write_offsets (sub->value_str, sub->value_pos, sub->offsets);
+
+ writer->value_pos += _dbus_string_get_length (sub->offsets);
+
+ _dbus_string_free (sub->offsets);
+ dbus_free (sub->offsets);
+ }
+
+ break;
+ default:
+ _dbus_assert_not_reached("Invalid container type");
+ }
+
+ /* well, we don't know where in the type string beginning of current container is */
+ result = result && _dbus_writer_gvariant_add_offset_with_variability (writer, sub->is_fixed);
+
+ return result;
+}
+
+void
+_dbus_type_reader_gvariant_init (DBusTypeReader *reader,
+ DBusMessage *message)
+{
+ reader->gvariant = TRUE;
+ /* GVariant wraps contents into struct */
+ if (_dbus_string_get_byte (reader->type_str, reader->type_pos) == DBUS_STRUCT_BEGIN_CHAR)
+ {
+ reader->type_pos++;
+ if (_dbus_string_get_byte (reader->type_str, reader->type_pos) == DBUS_STRUCT_END_CHAR)
+ reader->finished = TRUE;
+ }
+
+ reader->value_end = _dbus_message_gvariant_get_body_length (message);
+ reader->n_offsets = _dbus_reader_count_offsets (reader);
+}
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-marshal-gvariant.h Managing GVariant marshaling/demarshaling of messages
+ *
+ * Copyright (C) 2015 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef DBUS_MARSHAL_GVARIANT_H
+#define DBUS_MARSHAL_GVARIANT_H
+
+#include <dbus/dbus-marshal-header.h>
+#include <dbus/dbus-marshal-recursive.h>
+#include <dbus/dbus-message.h>
+#include <dbus/dbus-connection.h>
+
+const DBusString *_dbus_get_gvariant_header_signature_str (void);
+
+dbus_bool_t _dbus_header_gvariant_create (DBusHeader *header,
+ int byte_order,
+ int type,
+ const char *destination,
+ const char *path,
+ const char *interface,
+ const char *member,
+ const char *error_name);
+
+dbus_bool_t _dbus_type_writer_write_gvariant_basic (DBusTypeWriter *writer,
+ int type,
+ const void *value);
+
+dbus_bool_t _dbus_marshal_write_gvariant_basic (DBusString *str,
+ int insert_at,
+ int type,
+ const void *value,
+ int byte_order,
+ int *pos_after);
+
+dbus_bool_t _dbus_header_set_field_basic_gvariant (DBusHeader *header,
+ int field,
+ int type,
+ const void *value);
+
+dbus_bool_t _dbus_header_get_field_basic_gvariant (DBusHeader *header,
+ int field,
+ int type,
+ void *value);
+
+dbus_bool_t _dbus_header_gvariant_delete_field (DBusHeader *header,
+ int field);
+
+void _dbus_marshal_read_gvariant_basic (const DBusString *str,
+ int pos,
+ int type,
+ void *value,
+ int byte_order,
+ int *new_pos);
+
+void _dbus_marshal_skip_gvariant_basic (const DBusString *str,
+ int type,
+ int byte_order,
+ int *pos);
+
+dbus_bool_t _dbus_header_load_gvariant (DBusHeader *header,
+ DBusTypeReader *reader,
+ DBusValidity *validity);
+
+dbus_bool_t _dbus_gvariant_raw_get_lengths (const DBusString *str,
+ dbus_uint32_t *fields_array_len_unsigned,
+ dbus_uint32_t *body_len_unsigned,
+ DBusValidity *validity);
+
+DBusValidity _dbus_validate_gvariant_body_with_reason (const DBusString *expected_signature,
+ int expected_signature_start,
+ int byte_order,
+ int *bytes_remaining,
+ const DBusString *value_str,
+ int value_pos,
+ int len);
+
+dbus_bool_t _dbus_message_gvariant_get_signature (DBusMessage *message,
+ const DBusString **type_str_p,
+ int *type_pos_p,
+ int *type_str_len);
+
+dbus_bool_t _dbus_message_gvariant_add_signature (DBusMessage *message,
+ const DBusString *type_str);
+
+dbus_bool_t _dbus_message_append_body_offset (DBusMessage *message);
+dbus_bool_t _dbus_message_gvariant_remove_body_offset (DBusMessage *message);
+
+dbus_bool_t _dbus_message_finalize_gvariant (DBusMessage *message,
+ dbus_bool_t remove_signature_from_header);
+
+size_t _dbus_reader_get_offset_of_end_of_variable (DBusTypeReader *reader);
+int _dbus_reader_get_type_fixed_size (DBusTypeReader *reader,
+ int *alignment);
+
+int _dbus_type_gvariant_get_fixed_size (const DBusString *type_str,
+ int type_pos,
+ int *alignment);
+
+int _dbus_reader_count_offsets (const DBusTypeReader *reader);
+
+int _dbus_reader_count_array_elems (const DBusTypeReader *reader);
+
+dbus_bool_t _dbus_type_writer_gvariant_write_basic_no_typecode (DBusTypeWriter *writer,
+ int type,
+ const void *value);
+
+dbus_bool_t _dbus_writer_unrecurse_gvariant_write (DBusTypeWriter *writer,
+ DBusTypeWriter *sub);
+
+void _dbus_type_reader_gvariant_init (DBusTypeReader *reader,
+ DBusMessage *message);
+
+#endif /* DBUS_MARSHAL_GVARIANT_H */
#include "dbus-marshal-recursive.h"
#include "dbus-marshal-byteswap.h"
+#include "dbus-protocol-gvariant.h"
+#include "dbus-marshal-gvariant.h"
+
/**
* @addtogroup DBusMarshal
*
#define HEADER_END_BEFORE_PADDING(header) \
(_dbus_string_get_length (&(header)->data) - (header)->padding)
+static dbus_bool_t
+_dbus_header_is_gvariant (const DBusHeader *header)
+{
+ return (header->protocol_version == DBUS_PROTOCOL_VERSION_GVARIANT);
+}
+
/**
* Invalidates all fields in the cache. This may be used when the
* cache is totally uninitialized (contains junk) so should not
SERIAL_OFFSET,
serial,
_dbus_header_get_byte_order (header));
+ if (_dbus_header_is_gvariant (header))
+ _dbus_marshal_set_uint32 (&header->data,
+ SERIAL_OFFSET+4,
+ 0,
+ _dbus_header_get_byte_order (header));
}
/**
* for use. #NULL may be specified for some or all of the fields to
* avoid adding those fields. Some combinations of fields don't make
* sense, and passing them in will trigger an assertion failure.
+ * This is used only for dbus1 messages. GVariant uses _dbus_header_gvariant_create.
*
* @param header the header
* @param byte_order byte order of the header
int *body_len,
const DBusString *str,
int start,
- int len)
+ int len,
+ dbus_bool_t *is_gvariant)
{
dbus_uint32_t header_len_unsigned;
dbus_uint32_t fields_array_len_unsigned;
dbus_uint32_t body_len_unsigned;
+ dbus_uint32_t protocol_version;
+
_dbus_assert (start >= 0);
_dbus_assert (start < _DBUS_INT32_MAX / 2);
_dbus_assert (len >= 0);
return FALSE;
}
- _dbus_assert (FIELDS_ARRAY_LENGTH_OFFSET + 4 <= len);
- fields_array_len_unsigned = _dbus_marshal_read_uint32 (str, start + FIELDS_ARRAY_LENGTH_OFFSET,
- *byte_order, NULL);
+ protocol_version = _dbus_string_get_byte (str, start + VERSION_OFFSET);
+ if (DBUS_MAJOR_PROTOCOL_VERSION == protocol_version)
+ {
+ _dbus_assert (FIELDS_ARRAY_LENGTH_OFFSET + 4 <= len);
+ fields_array_len_unsigned = _dbus_marshal_read_uint32 (str, start + FIELDS_ARRAY_LENGTH_OFFSET,
+ *byte_order, NULL);
+
+ _dbus_assert (BODY_LENGTH_OFFSET + 4 < len);
+ body_len_unsigned = _dbus_marshal_read_uint32 (str, start + BODY_LENGTH_OFFSET,
+ *byte_order, NULL);
+
+ *is_gvariant = FALSE;
+ }
+ else if (DBUS_PROTOCOL_VERSION_GVARIANT == protocol_version)
+ {
+ if (!_dbus_gvariant_raw_get_lengths (str, &fields_array_len_unsigned, &body_len_unsigned, validity))
+ {
+ return FALSE;
+ }
+ *is_gvariant = TRUE;
+ }
+ else
+ {
+ *validity = DBUS_INVALID_BAD_PROTOCOL_VERSION;
+ return FALSE;
+ }
if (fields_array_len_unsigned > (unsigned) max_message_length)
{
return FALSE;
}
- _dbus_assert (BODY_LENGTH_OFFSET + 4 < len);
- body_len_unsigned = _dbus_marshal_read_uint32 (str, start + BODY_LENGTH_OFFSET,
- *byte_order, NULL);
-
if (body_len_unsigned > (unsigned) max_message_length)
{
*validity = DBUS_INVALID_INSANE_BODY_LENGTH;
return DBUS_VALID;
}
+static dbus_bool_t
+_dbus_header_load_dbus1 (DBusHeader *header,
+ DBusTypeReader *reader,
+ DBusValidity *validity,
+ int body_len)
+{
+ dbus_uint32_t v_uint32;
+ dbus_uint32_t serial;
+ DBusTypeReader array_reader;
+
+ /* BODY LENGTH */
+ _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_UINT32);
+ _dbus_assert (_dbus_type_reader_get_value_pos (reader) == BODY_LENGTH_OFFSET);
+ _dbus_type_reader_read_basic (reader, &v_uint32);
+ _dbus_type_reader_next (reader);
+
+ _dbus_assert (body_len == (signed) v_uint32);
+
+ /* SERIAL */
+ _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_UINT32);
+ _dbus_assert (_dbus_type_reader_get_value_pos (reader) == SERIAL_OFFSET);
+ _dbus_type_reader_read_basic (reader, &serial);
+ _dbus_type_reader_next (reader);
+
+ if (serial == 0)
+ {
+ *validity = DBUS_INVALID_BAD_SERIAL;
+ return FALSE;
+ }
+
+ _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY);
+ _dbus_assert (_dbus_type_reader_get_value_pos (reader) == FIELDS_ARRAY_LENGTH_OFFSET);
+
+ _dbus_type_reader_recurse (reader, &array_reader);
+ while (_dbus_type_reader_get_current_type (&array_reader) != DBUS_TYPE_INVALID)
+ {
+ DBusTypeReader struct_reader;
+ DBusTypeReader variant_reader;
+ unsigned char field_code;
+ DBusValidity v;
+
+ _dbus_assert (_dbus_type_reader_get_current_type (&array_reader) == DBUS_TYPE_STRUCT);
+
+ _dbus_type_reader_recurse (&array_reader, &struct_reader);
+
+ _dbus_assert (_dbus_type_reader_get_current_type (&struct_reader) == DBUS_TYPE_BYTE);
+ _dbus_type_reader_read_basic (&struct_reader, &field_code);
+ _dbus_type_reader_next (&struct_reader);
+
+ if (field_code == DBUS_HEADER_FIELD_INVALID)
+ {
+ _dbus_verbose ("invalid header field code\n");
+ *validity = DBUS_INVALID_HEADER_FIELD_CODE;
+ return FALSE;
+ }
+
+ if (field_code > DBUS_HEADER_FIELD_LAST)
+ {
+ _dbus_verbose ("unknown header field code %d, skipping\n",
+ field_code);
+ goto next_field;
+ }
+
+ _dbus_assert (_dbus_type_reader_get_current_type (&struct_reader) == DBUS_TYPE_VARIANT);
+ _dbus_type_reader_recurse (&struct_reader, &variant_reader);
+
+ v = load_and_validate_field (header, field_code, &variant_reader);
+ if (v != DBUS_VALID)
+ {
+ _dbus_verbose ("Field %d was invalid\n", field_code);
+ *validity = v;
+ return FALSE;
+ }
+
+ next_field:
+ _dbus_type_reader_next (&array_reader);
+ }
+ return TRUE;
+}
+
/**
* Creates a message header from potentially-untrusted data. The
* return value is #TRUE if there was enough memory and the data was
int leftover;
DBusValidity v;
DBusTypeReader reader;
- DBusTypeReader array_reader;
unsigned char v_byte;
- dbus_uint32_t v_uint32;
- dbus_uint32_t serial;
int padding_start;
int padding_len;
int i;
+ const DBusString *signature;
_dbus_assert (start == (int) _DBUS_ALIGN_VALUE (start, 8));
_dbus_assert (header_len <= len);
*validity = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;
return FALSE;
}
+ if (_dbus_header_is_gvariant (header))
+ {
+ signature = _dbus_get_gvariant_header_signature_str();
+ }
+ else
+ {
+ signature = &_dbus_header_signature_str;
+ }
if (mode == DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY)
{
}
else
{
- v = _dbus_validate_body_with_reason (&_dbus_header_signature_str, 0,
- byte_order,
- &leftover,
- str, start, len);
+ if (!_dbus_header_is_gvariant (header))
+ {
+ v = _dbus_validate_body_with_reason (signature, 0,
+ byte_order,
+ &leftover,
+ str, start, len);
+ }
+ else
+ {
+ v = _dbus_validate_gvariant_body_with_reason (signature, 0,
+ byte_order,
+ &leftover,
+ str, start, len);
+ }
if (v != DBUS_VALID)
{
_dbus_type_reader_init (&reader,
byte_order,
- &_dbus_header_signature_str, 0,
+ signature, 0,
str, start);
/* BYTE ORDER */
if (v_byte != DBUS_MAJOR_PROTOCOL_VERSION)
{
- *validity = DBUS_INVALID_BAD_PROTOCOL_VERSION;
- goto invalid;
+ if (v_byte == DBUS_PROTOCOL_VERSION_GVARIANT)
+ {
+ reader.gvariant = TRUE;
+ }
+ else
+ {
+ *validity = DBUS_INVALID_BAD_PROTOCOL_VERSION;
+ goto invalid;
+ }
}
-
- /* BODY LENGTH */
- _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_UINT32);
- _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == BODY_LENGTH_OFFSET);
- _dbus_type_reader_read_basic (&reader, &v_uint32);
- _dbus_type_reader_next (&reader);
-
- _dbus_assert (body_len == (signed) v_uint32);
-
- /* SERIAL */
- _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_UINT32);
- _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == SERIAL_OFFSET);
- _dbus_type_reader_read_basic (&reader, &serial);
- _dbus_type_reader_next (&reader);
-
- if (serial == 0)
+ if (reader.gvariant)
{
- *validity = DBUS_INVALID_BAD_SERIAL;
- goto invalid;
+ if (!_dbus_header_load_gvariant (header, &reader, validity))
+ goto invalid;
}
-
- _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_ARRAY);
- _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == FIELDS_ARRAY_LENGTH_OFFSET);
-
- _dbus_type_reader_recurse (&reader, &array_reader);
- while (_dbus_type_reader_get_current_type (&array_reader) != DBUS_TYPE_INVALID)
+ else
{
- DBusTypeReader struct_reader;
- DBusTypeReader variant_reader;
- unsigned char field_code;
-
- _dbus_assert (_dbus_type_reader_get_current_type (&array_reader) == DBUS_TYPE_STRUCT);
-
- _dbus_type_reader_recurse (&array_reader, &struct_reader);
-
- _dbus_assert (_dbus_type_reader_get_current_type (&struct_reader) == DBUS_TYPE_BYTE);
- _dbus_type_reader_read_basic (&struct_reader, &field_code);
- _dbus_type_reader_next (&struct_reader);
-
- if (field_code == DBUS_HEADER_FIELD_INVALID)
- {
- _dbus_verbose ("invalid header field code\n");
- *validity = DBUS_INVALID_HEADER_FIELD_CODE;
- goto invalid;
- }
-
- if (field_code > DBUS_HEADER_FIELD_LAST)
- {
- _dbus_verbose ("unknown header field code %d, skipping\n",
- field_code);
- goto next_field;
- }
-
- _dbus_assert (_dbus_type_reader_get_current_type (&struct_reader) == DBUS_TYPE_VARIANT);
- _dbus_type_reader_recurse (&struct_reader, &variant_reader);
-
- v = load_and_validate_field (header, field_code, &variant_reader);
- if (v != DBUS_VALID)
- {
- _dbus_verbose ("Field %d was invalid\n", field_code);
- *validity = v;
- goto invalid;
- }
-
- next_field:
- _dbus_type_reader_next (&array_reader);
+ if (!_dbus_header_load_dbus1 (header, &reader, validity, body_len))
+ goto invalid;
}
/* Anything we didn't fill in is now known not to exist */
return retval;
}
-/**
- * Sets the value of a field with basic type. If the value is a string
- * value, it isn't allowed to be #NULL. If the field doesn't exist,
- * it will be created.
- *
- * @param header the header
- * @param field the field to set
- * @param type the type of the value
- * @param value the value as for _dbus_marshal_set_basic()
- * @returns #FALSE if no memory
- */
-dbus_bool_t
-_dbus_header_set_field_basic (DBusHeader *header,
+static dbus_bool_t
+_dbus_header_set_field_basic_dbus1 (DBusHeader *header,
int field,
int type,
const void *value)
}
/**
- * Gets the value of a field with basic type. If the field
- * doesn't exist, returns #FALSE, otherwise returns #TRUE.
+ * Sets the value of a field with basic type. If the value is a string
+ * value, it isn't allowed to be #NULL. If the field doesn't exist,
+ * it will be created.
*
* @param header the header
- * @param field the field to get
+ * @param field the field to set
* @param type the type of the value
- * @param value the value as for _dbus_marshal_read_basic()
- * @returns #FALSE if the field doesn't exist
+ * @param value the value as for _dbus_marshal_set_basic()
+ * @returns #FALSE if no memory
*/
dbus_bool_t
-_dbus_header_get_field_basic (DBusHeader *header,
+_dbus_header_set_field_basic (DBusHeader *header,
+ int field,
+ int type,
+ const void *value)
+{
+ return _dbus_header_is_gvariant (header) ?
+ _dbus_header_set_field_basic_gvariant (header, field, type, value) :
+ _dbus_header_set_field_basic_dbus1 (header, field, type, value);
+}
+
+static dbus_bool_t
+_dbus_header_get_field_basic_dbus1 (DBusHeader *header,
int field,
int type,
void *value)
return TRUE;
}
+/**
+ * Gets the value of a field with basic type. If the field
+ * doesn't exist, returns #FALSE, otherwise returns #TRUE.
+ *
+ * @param header the header
+ * @param field the field to get
+ * @param type the type of the value
+ * @param value the value as for _dbus_marshal_read_basic()
+ * @returns #FALSE if the field doesn't exist
+ */
+dbus_bool_t
+_dbus_header_get_field_basic (DBusHeader *header,
+ int field,
+ int type,
+ void *value)
+{
+ return _dbus_header_is_gvariant (header) ?
+ _dbus_header_get_field_basic_gvariant (header, field, type, value) :
+ _dbus_header_get_field_basic_dbus1 (header, field, type, value);
+}
/**
* Gets the raw marshaled data for a field. If the field doesn't
dbus_uint32_t padding : 3; /**< bytes of alignment in header */
dbus_uint32_t byte_order : 8; /**< byte order of header */
+ unsigned char protocol_version;
};
dbus_bool_t _dbus_header_init (DBusHeader *header);
int *body_len,
const DBusString *str,
int start,
- int len);
+ int len,
+ dbus_bool_t *is_gvariant);
dbus_bool_t _dbus_header_load (DBusHeader *header,
DBusValidationMode mode,
DBusValidity *validity,
/* dbus-marshal-recursive.c Marshalling routines for recursive types
*
* Copyright (C) 2004, 2005 Red Hat, Inc.
+ * Copyright (C) 2015 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
#include "dbus-marshal-basic.h"
#include "dbus-signature.h"
#include "dbus-internals.h"
+#include "dbus-marshal-gvariant.h"
/**
* @addtogroup DBusMarshal
const DBusString *type_str,
int type_pos,
const DBusString *value_str,
- int value_pos)
+ int value_pos,
+ dbus_bool_t gvariant)
{
reader->byte_order = byte_order;
reader->finished = FALSE;
reader->type_pos = type_pos;
reader->value_str = value_str;
reader->value_pos = value_pos;
+ reader->value_start = value_pos;
+ reader->gvariant = gvariant;
+ reader->variable_index = 0;
+ reader->offsets_from_back = TRUE;
+ reader->is_variant = FALSE;
}
static void
parent->type_str,
parent->type_pos,
parent->value_str,
- parent->value_pos);
+ parent->value_pos,
+ parent->gvariant);
}
static void
{
struct_or_dict_entry_types_only_reader_recurse (sub, parent);
- /* struct and dict entry have 8 byte alignment */
- sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
+ if (sub->gvariant)
+ {
+ /* GVARIANT */
+ /* check if current type is fixed or variable */
+ int alignment = 1;
+ int size = _dbus_reader_get_type_fixed_size (parent, &alignment);
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment); /* adjust alignment */
+ sub->value_start = sub->value_pos;
+ sub->n_offsets = _dbus_reader_count_offsets (sub);
+ sub->offsets_from_back = TRUE;
+
+ if (0 == size)
+ {
+ sub->value_end = _dbus_reader_get_offset_of_end_of_variable (parent);
+ }
+ else
+ {
+ sub->value_end = sub->value_pos + size;
+ }
+ }
+ else
+ {
+ /* struct and dict entry have 8 byte alignment */
+ sub->value_pos = sub->value_start = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
+ }
}
static void
dbus_uint32_t array_len;
int len_pos;
+ if (reader->gvariant)
+ return reader->value_end - reader->value_start;
+
len_pos = ARRAY_READER_LEN_POS (reader);
_dbus_assert (_DBUS_ALIGN_VALUE (len_pos, 4) == (unsigned) len_pos);
array_types_only_reader_recurse (sub, parent);
- sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
+ if (sub->gvariant)
+ {
+ int size = _dbus_reader_get_type_fixed_size (sub, &alignment);
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
+ sub->value_start = sub->value_pos;
+ sub->offsets_from_back = FALSE;
+ sub->value_end = _dbus_reader_get_offset_of_end_of_variable (parent);
+ sub->variable_index = 0;
+ if (0 == size)
+ sub->n_offsets = _dbus_reader_count_array_elems (sub);
+ else
+ sub->n_offsets = 0;
+ sub->u.array.start_pos = sub->value_start;
+ sub->finished = (sub->value_end == sub->value_start);
+ }
+ else
+ {
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
- len_pos = sub->value_pos;
+ len_pos = sub->value_pos;
- sub->value_pos += 4; /* for the length */
+ sub->value_pos += 4; /* for the length */
- alignment = element_type_get_alignment (sub->type_str,
- sub->type_pos);
+ alignment = element_type_get_alignment (sub->type_str,
+ sub->type_pos);
- sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
- sub->u.array.start_pos = sub->value_pos;
- _dbus_assert ((sub->u.array.start_pos - (len_pos + 4)) < 8); /* only 3 bits in array_len_offset */
- sub->array_len_offset = sub->u.array.start_pos - (len_pos + 4);
+ sub->u.array.start_pos = sub->value_pos;
+ _dbus_assert ((sub->u.array.start_pos - (len_pos + 4)) < 8); /* only 3 bits in array_len_offset */
+ sub->array_len_offset = sub->u.array.start_pos - (len_pos + 4);
+ }
#if RECURSIVE_MARSHAL_READ_TRACE
_dbus_verbose (" type reader %p array start = %d len_offset = %d array len = %d array element type = %s\n",
base_reader_recurse (sub, parent);
- /* Variant is 1 byte sig length (without nul), signature with nul,
- * padding to 8-boundary, then values
- */
+ if (sub->gvariant)
+ {
+ /* GVariant's Variant is values, then nul byte, then signature.
+ * Variant's alignment is 8.
+ */
+ sub->value_pos = sub->value_start = _DBUS_ALIGN_VALUE (sub->value_pos, 8); /* adjust alignment */
+ sub->value_end = _dbus_reader_get_offset_of_end_of_variable (parent);
- sig_len = _dbus_string_get_byte (sub->value_str, sub->value_pos);
+ /* find beginning of signature in variant */
+ sub->type_str = sub->value_str;
+ sub->type_pos = sub->value_end - 1;
- sub->type_str = sub->value_str;
- sub->type_pos = sub->value_pos + 1;
+ while (sub->type_pos > 0 && _dbus_string_get_byte (sub->type_str, sub->type_pos) != 0)
+ sub->type_pos--;
- sub->value_pos = sub->type_pos + sig_len + 1;
+ if (_dbus_string_get_byte (sub->type_str, sub->type_pos) == 0)
+ sub->type_pos++;
- contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (sub->type_str,
- sub->type_pos));
-
- sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
+ /* set the end of variant's value to the zero byte before signature */
+ sub->value_end = sub->type_pos - 1;
+ sub->is_variant = TRUE;
+ }
+ else
+ {
+ /* Variant is 1 byte sig length (without nul), signature with nul,
+ * padding to 8-boundary, then values
+ */
+
+ sig_len = _dbus_string_get_byte (sub->value_str, sub->value_pos);
+
+ sub->type_str = sub->value_str;
+ sub->type_pos = sub->value_pos + 1;
+
+ sub->value_pos = sub->type_pos + sig_len + 1;
+
+ contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (sub->type_str,
+ sub->type_pos));
+
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
+ }
#if RECURSIVE_MARSHAL_READ_TRACE
_dbus_verbose (" type reader %p variant containing '%s'\n",
*/
void
_dbus_type_signature_next (const char *type_str,
- int *type_pos)
+ int *type_pos)
{
const unsigned char *p;
const unsigned char *start;
case DBUS_TYPE_STRUCT:
case DBUS_TYPE_VARIANT:
/* Scan forward over the entire container contents */
+ /* FIXME for GVariant - use offsets */
{
DBusTypeReader sub;
default:
if (!reader->klass->types_only)
- _dbus_marshal_skip_basic (reader->value_str,
+ (reader->gvariant ? _dbus_marshal_skip_gvariant_basic : _dbus_marshal_skip_basic) (
+ reader->value_str,
current_type, reader->byte_order,
&reader->value_pos);
}
static void
+struct_or_dict_entry_reader_next (DBusTypeReader *reader,
+ int current_type)
+{
+ if (reader->gvariant)
+ {
+ int alignment;
+ int size = _dbus_reader_get_type_fixed_size (reader, &alignment);
+ if (0 == size)
+ {
+ /* variable size - use offsets*/
+ reader->value_pos = _dbus_reader_get_offset_of_end_of_variable (reader);
+ reader->variable_index++;
+ }
+ else
+ {
+ /* just move, but consider alignment */
+ reader->value_pos = _DBUS_ALIGN_VALUE(reader->value_pos, alignment) + size;
+ }
+
+ skip_one_complete_type (reader->type_str, &reader->type_pos);
+ }
+ else
+ {
+ base_reader_next (reader, current_type);
+ }
+}
+
+static void
struct_reader_next (DBusTypeReader *reader,
int current_type)
{
int t;
- base_reader_next (reader, current_type);
+ struct_or_dict_entry_reader_next (reader, current_type);
/* for STRUCT containers we return FALSE at the end of the struct,
* for INVALID we return FALSE at the end of the signature.
}
static void
+body_reader_next (DBusTypeReader *reader,
+ int current_type)
+{
+ if (reader->gvariant)
+ struct_reader_next (reader, current_type);
+ else
+ base_reader_next (reader, current_type);
+}
+
+static void
dict_entry_reader_next (DBusTypeReader *reader,
int current_type)
{
int t;
- base_reader_next (reader, current_type);
+ struct_or_dict_entry_reader_next (reader, current_type);
/* for STRUCT containers we return FALSE at the end of the struct,
* for INVALID we return FALSE at the end of the signature.
/* Skip one array element */
int end_pos;
+ if (reader->gvariant)
+ {
+ int alignment;
+ int size = _dbus_reader_get_type_fixed_size (reader, &alignment);
+ if (0 == size)
+ {
+ /* variable size - use offsets*/
+ reader->value_pos = _dbus_reader_get_offset_of_end_of_variable (reader);
+ reader->variable_index++;
+ reader->finished = (reader->variable_index >= reader->n_offsets);
+ }
+ else
+ {
+ /* fixed size - move on; consider alignment */
+ reader->value_pos = _DBUS_ALIGN_VALUE(reader->value_pos, alignment) + size;
+ reader->finished = (reader->value_pos >= reader->value_end);
+ }
+ return;
+ }
+
end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
#if RECURSIVE_MARSHAL_READ_TRACE
}
}
+static void
+variant_reader_next (DBusTypeReader *reader,
+ int current_type)
+{
+ if (reader->gvariant)
+ {
+ if (!reader->klass->types_only)
+ reader->value_pos = reader->value_end;
+
+ reader->type_pos += 1;
+
+ reader->finished = TRUE;
+
+ reader->variable_index++;
+ }
+ else
+ {
+ base_reader_next (reader, current_type);
+ }
+}
+
static const DBusTypeReaderClass body_reader_class = {
"body", 0,
FALSE,
NULL, /* body is always toplevel, so doesn't get recursed into */
NULL,
- base_reader_next
+ body_reader_next
};
static const DBusTypeReaderClass body_types_only_reader_class = {
TRUE,
NULL, /* body is always toplevel, so doesn't get recursed into */
NULL,
- base_reader_next
+ body_reader_next
};
static const DBusTypeReaderClass struct_reader_class = {
FALSE,
variant_reader_recurse,
NULL,
- base_reader_next
+ variant_reader_next
};
#ifndef DBUS_DISABLE_ASSERT
reader->klass = &body_reader_class;
reader_init (reader, byte_order, type_str, type_pos,
- value_str, value_pos);
+ value_str, value_pos, FALSE);
#if RECURSIVE_MARSHAL_READ_TRACE
_dbus_verbose (" type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
reader->klass = &body_types_only_reader_class;
reader_init (reader, DBUS_COMPILER_BYTE_ORDER /* irrelevant */,
- type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */);
+ type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */,
+ FALSE);
#if RECURSIVE_MARSHAL_READ_TRACE
_dbus_verbose (" type reader %p init types only type_pos = %d remaining sig '%s'\n",
t = _dbus_type_reader_get_current_type (reader);
- _dbus_marshal_read_basic (reader->value_str,
+ (reader->gvariant ? _dbus_marshal_read_gvariant_basic : _dbus_marshal_read_basic) (
+ reader->value_str,
reader->value_pos,
t, value,
reader->byte_order,
writer->type_pos = type_pos;
writer->value_str = value_str;
writer->value_pos = value_pos;
+ writer->value_start = value_pos;
writer->container_type = DBUS_TYPE_INVALID;
writer->type_pos_is_expectation = FALSE;
writer->enabled = TRUE;
+ writer->gvariant = FALSE;
+ writer->body_container = FALSE;
+ writer->is_fixed = TRUE;
+ writer->alignment = 1;
#if RECURSIVE_MARSHAL_WRITE_TRACE
_dbus_verbose ("writer %p init remaining sig '%s'\n", writer,
NULL, 0, value_str, value_pos);
}
+void
+_dbus_type_writer_gvariant_init_types_delayed (DBusTypeWriter *writer,
+ int byte_order,
+ DBusString *value_str,
+ int value_pos,
+ dbus_bool_t gvariant)
+{
+ _dbus_type_writer_init (writer, byte_order,
+ NULL, 0, value_str, value_pos);
+ writer->gvariant = gvariant;
+ writer->body_container = TRUE;
+ writer->is_fixed = TRUE;
+ writer->alignment = 8;
+ writer->u.struct_or_dict.last_offset = 0;
+ writer->offsets_size = 1;
+ writer->offsets = NULL;
+}
+
/**
* Adds type string to the writer, if it had none.
*
const void *value)
{
if (writer->enabled)
- return _dbus_marshal_write_basic (writer->value_str,
- writer->value_pos,
- type,
- value,
- writer->byte_order,
- &writer->value_pos);
+ {
+ if (writer->gvariant)
+ {
+ return _dbus_type_writer_gvariant_write_basic_no_typecode (writer, type, value);
+ }
+ else
+ return _dbus_marshal_write_basic (writer->value_str,
+ writer->value_pos,
+ type,
+ value,
+ writer->byte_order,
+ &writer->value_pos);
+ }
else
return TRUE;
}
writer->value_pos);
sub->container_type = container_type;
+ sub->gvariant = writer->gvariant;
if (writer->type_pos_is_expectation ||
(sub->container_type == DBUS_TYPE_ARRAY || sub->container_type == DBUS_TYPE_VARIANT))
if (writer->enabled)
{
- if (!_dbus_string_insert_bytes (sub->value_str,
- sub->value_pos,
- _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
- '\0'))
- _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct");
- sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
+ if (writer->gvariant)
+ {
+ sub->alignment = 1;
+ sub->value_str = dbus_new (DBusString, 1);
+ if (NULL == sub->value_str || !_dbus_string_init (sub->value_str))
+ return FALSE;
+ sub->value_start = sub->value_pos = 0;
+ sub->u.struct_or_dict.last_offset = 0;
+ sub->offsets_size = 1;
+ sub->is_fixed = TRUE;
+ sub->offsets = dbus_new (DBusString, 1);
+ _dbus_string_init (sub->offsets);
+ }
+ else
+ {
+ if (!_dbus_string_insert_bytes (sub->value_str,
+ sub->value_pos,
+ _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
+ '\0'))
+ _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct");
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
+ }
}
return TRUE;
if (writer->enabled)
{
- /* Write (or jump over, if is_array_append) the length */
- sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
-
- if (is_array_append)
- {
- sub->value_pos += 4;
- }
- else
+ if (!writer->gvariant)
{
- if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32,
- &value))
- _dbus_assert_not_reached ("should not have failed to insert array len");
- }
+ /* Write (or jump over, if is_array_append) the length */
+ sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
+
+ if (is_array_append)
+ {
+ sub->value_pos += 4;
+ }
+ else
+ {
+ if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32, &value))
+ _dbus_assert_not_reached ("should not have failed to insert array len");
+ }
- _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
+ _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
+ }
/* Write alignment padding for array elements
* Note that we write the padding *even for empty arrays*
* to avoid wonky special cases
*/
- alignment = element_type_get_alignment (contained_type, contained_type_start);
+ if (writer->gvariant)
+ {
+ int size = _dbus_type_gvariant_get_fixed_size (contained_type, contained_type_start, &alignment);
+ if (0 == size)
+ {
+ sub->offsets_size = 1;
+ sub->offsets = dbus_new (DBusString, 1);
+ _dbus_string_init (sub->offsets);
+ }
+ else
+ {
+ sub->offsets_size = 0;
+ sub->offsets = NULL;
+ }
+ }
+ else
+ {
+ alignment = element_type_get_alignment (contained_type, contained_type_start);
+ }
aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
if (aligned != sub->value_pos)
sub->u.array.start_pos = sub->value_pos;
- if (is_array_append)
+ if (is_array_append && !writer->gvariant)
{
dbus_uint32_t len;
sub->value_pos += len;
}
+ if (writer->gvariant)
+ {
+ sub->alignment = alignment;
+ sub->is_fixed = FALSE;
+ sub->value_start = sub->value_pos;
+ }
}
else
{
sub->u.array.start_pos = sub->value_pos;
}
- _dbus_assert (sub->u.array.len_pos < sub->u.array.start_pos);
+ _dbus_assert (sub->gvariant || sub->u.array.len_pos < sub->u.array.start_pos);
_dbus_assert (is_array_append || sub->u.array.start_pos == sub->value_pos);
#if RECURSIVE_MARSHAL_WRITE_TRACE
/* If we're enabled then continue ... */
- if (!_dbus_string_insert_byte (sub->value_str,
- sub->value_pos,
- contained_type_len))
- _dbus_assert_not_reached ("should not have failed to insert variant type sig len");
+ if (writer->gvariant)
+ {
+ /* GVariant case:
+ * contents, then nul byte, then signature without nul byte.
+ * The alignment is always 8.
+ *
+ * Signature is at the end of a variant. So, the easiest way is to write it down
+ * when unrecursing. So, we need to copy it to a new string.
+ */
+ contained_alignment = 8;
+ sub->alignment = 8;
+ sub->type_str = dbus_new (DBusString, 1); /* to be deallocated on unrecurse */
+ sub->type_pos = 0;
+ sub->is_fixed = FALSE;
+ _dbus_string_init_preallocated (sub->type_str, contained_type_len);
+
+ if (!_dbus_string_copy_len (contained_type, contained_type_start, contained_type_len,
+ sub->type_str, sub->type_pos))
+ _dbus_assert_not_reached ("should not have failed to insert variant type sig");
+ }
+ else
+ {
+ /* dbus1 case:
+ * length, signature with nul byte, then contents
+ * alignment depends on contents.
+ */
+ if (!_dbus_string_insert_byte (sub->value_str,
+ sub->value_pos,
+ contained_type_len))
+ _dbus_assert_not_reached ("should not have failed to insert variant type sig len");
- sub->value_pos += 1;
+ sub->value_pos += 1;
- /* Here we switch over to the expected type sig we're about to write */
- sub->type_str = sub->value_str;
- sub->type_pos = sub->value_pos;
+ /* Here we switch over to the expected type sig we're about to write */
+ sub->type_str = sub->value_str;
+ sub->type_pos = sub->value_pos;
- if (!_dbus_string_copy_len (contained_type, contained_type_start, contained_type_len,
- sub->value_str, sub->value_pos))
- _dbus_assert_not_reached ("should not have failed to insert variant type sig");
+ if (!_dbus_string_copy_len (contained_type, contained_type_start, contained_type_len,
+ sub->value_str, sub->value_pos))
+ _dbus_assert_not_reached ("should not have failed to insert variant type sig");
- sub->value_pos += contained_type_len;
+ sub->value_pos += contained_type_len;
- if (!_dbus_string_insert_byte (sub->value_str,
- sub->value_pos,
- DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("should not have failed to insert variant type nul termination");
+ if (!_dbus_string_insert_byte (sub->value_str,
+ sub->value_pos,
+ DBUS_TYPE_INVALID))
+ _dbus_assert_not_reached ("should not have failed to insert variant type nul termination");
- sub->value_pos += 1;
+ sub->value_pos += 1;
- contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (contained_type, contained_type_start));
+ contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (contained_type, contained_type_start));
+ }
if (!_dbus_string_insert_bytes (sub->value_str,
sub->value_pos,
'\0'))
_dbus_assert_not_reached ("should not have failed to insert alignment padding for variant body");
sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
+ sub->value_start = sub->value_pos;
return TRUE;
}
else
contained_type_len = 0;
+ sub->body_container = FALSE;
+
return _dbus_type_writer_recurse_contained_len (writer, container_type,
contained_type,
contained_type_start,
return writer->value_pos - writer->u.array.start_pos;
}
-/**
- * Closes a container created by _dbus_type_writer_recurse()
- * and writes any additional information to the values block.
- *
- * @param writer the writer
- * @param sub the sub-writer created by _dbus_type_writer_recurse()
- * @returns #FALSE if no memory
- */
-dbus_bool_t
-_dbus_type_writer_unrecurse (DBusTypeWriter *writer,
- DBusTypeWriter *sub)
+static dbus_bool_t
+_dbus_type_writer_unrecurse_write (DBusTypeWriter *writer,
+ DBusTypeWriter *sub)
{
- /* type_pos_is_expectation never gets unset once set, or we'd get all hosed */
- _dbus_assert (!writer->type_pos_is_expectation ||
- (writer->type_pos_is_expectation && sub->type_pos_is_expectation));
-
-#if RECURSIVE_MARSHAL_WRITE_TRACE
- _dbus_verbose (" type writer %p unrecurse type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
- writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
- _dbus_type_to_string (writer->container_type));
- _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
- sub, sub->type_pos, sub->value_pos,
- sub->type_pos_is_expectation,
- _dbus_type_to_string (sub->container_type));
-#endif
-
if (sub->container_type == DBUS_TYPE_STRUCT)
{
if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR))
if (!write_or_verify_typecode (sub, DBUS_DICT_ENTRY_END_CHAR))
return FALSE;
}
- else if (sub->container_type == DBUS_TYPE_ARRAY)
+ else if (sub->container_type == DBUS_TYPE_ARRAY && !sub->gvariant)
{
if (sub->u.array.len_pos >= 0) /* len_pos == -1 if we weren't enabled when we passed it */
{
}
#endif
}
+ return TRUE;
+}
+
+/**
+ * Closes a container created by _dbus_type_writer_recurse()
+ * and writes any additional information to the values block.
+ *
+ * @param writer the writer
+ * @param sub the sub-writer created by _dbus_type_writer_recurse()
+ * @returns #FALSE if no memory
+ */
+dbus_bool_t
+_dbus_type_writer_unrecurse (DBusTypeWriter *writer,
+ DBusTypeWriter *sub)
+{
+ /* type_pos_is_expectation never gets unset once set, or we'd get all hosed */
+ _dbus_assert (!writer->type_pos_is_expectation ||
+ (writer->type_pos_is_expectation && sub->type_pos_is_expectation));
+
+#if RECURSIVE_MARSHAL_WRITE_TRACE
+ _dbus_verbose (" type writer %p unrecurse type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
+ writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
+ _dbus_type_to_string (writer->container_type));
+ _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
+ sub, sub->type_pos, sub->value_pos,
+ sub->type_pos_is_expectation,
+ _dbus_type_to_string (sub->container_type));
+#endif
+
+ if (!_dbus_type_writer_unrecurse_write (writer, sub))
+ return FALSE;
+
+ if (writer->gvariant)
+ {
+ if (!_dbus_writer_unrecurse_gvariant_write (writer, sub))
+ return FALSE;
+ }
+ else
+ writer->value_pos = sub->value_pos;
+
/* Now get type_pos right for the parent writer. Here are the cases:
*
}
}
- writer->value_pos = sub->value_pos;
-
#if RECURSIVE_MARSHAL_WRITE_TRACE
_dbus_verbose (" type writer %p unrecursed type_pos = %d value_pos = %d remaining sig '%s'\n",
writer, writer->type_pos, writer->value_pos,
/* dbus-marshal-recursive.h Marshalling routines for recursive types
*
* Copyright (C) 2004, 2005 Red Hat, Inc.
+ * Copyright (C) 2015 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
* where we don't have another way to tell
*/
dbus_uint32_t array_len_offset : 3; /**< bytes back from start_pos that len ends */
+ dbus_uint32_t gvariant : 1; /**< TRUE if gvariant marshaling should be used */
+ dbus_uint32_t offsets_from_back : 1; /**< for GVariant marshalling: direction of offsets */
+ dbus_uint32_t is_variant : 1; /**< for GVariant marshalling: indicator of variant type */
const DBusString *type_str; /**< string containing signature of block */
int type_pos; /**< current position in signature */
const DBusString *value_str; /**< string containing values of block */
int value_pos; /**< current position in values */
+ int variable_index; /**< index of value within variable values in the container */
+ size_t value_start; /**< start of container */
+ size_t value_end; /**< end of container */
+ int n_offsets; /**< for GVariant marshalling: number of variable offsets */
const DBusTypeReaderClass *klass; /**< the vtable for the reader */
union
dbus_uint32_t enabled : 1; /**< whether to write values */
+ dbus_uint32_t gvariant : 1; /**< TRUE if gvariant marshaling should be used */
+ dbus_uint32_t body_container : 1; /**< TRUE if this writer is top-level */
+ dbus_uint32_t is_fixed : 1; /**< TRUE if this writer wrote only fixed-size values so far */
+
DBusString *type_str; /**< where to write typecodes (or read type expectations) */
int type_pos; /**< current pos in type_str */
DBusString *value_str; /**< where to write values */
int value_pos; /**< next position to write */
+ size_t value_start; /**< start of the container */
+ DBusString *offsets; /**< for GVariant marshalling: actual offsets */
+ int alignment; /**< for GVariant marshalling: for enclosing containers */
+ char offsets_size; /**< for GVariant marshalling: current size of offsets */
union
{
int len_pos; /**< position of length of the array */
int element_type_pos; /**< position of array element type in type_str */
} array;
+ struct {
+ size_t last_offset; /**< for GVariant marshalling: position of end of last field */
+ } struct_or_dict;
} u; /**< class-specific data */
};
int byte_order,
DBusString *value_str,
int value_pos);
+void _dbus_type_writer_gvariant_init_types_delayed (DBusTypeWriter *writer,
+ int byte_order,
+ DBusString *value_str,
+ int value_pos,
+ dbus_bool_t gvariant);
void _dbus_type_writer_add_types (DBusTypeWriter *writer,
DBusString *type_str,
int type_pos);
dbus_bool_t _dbus_type_writer_write_basic (DBusTypeWriter *writer,
int type,
const void *value);
+dbus_bool_t _dbus_type_writer_write_basic_with_gvariant
+ (DBusTypeWriter *writer,
+ int type,
+ const void *value,
+ dbus_bool_t gvariant);
dbus_bool_t _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer,
int element_type,
const void *value,
void _dbus_message_loader_set_max_message_unix_fds(DBusMessageLoader *loader,
long n);
long _dbus_message_loader_get_max_message_unix_fds(DBusMessageLoader *loader);
+void _dbus_message_loader_set_unique_sender_id (DBusMessageLoader *loader,
+ uint64_t id);
+uint64_t _dbus_message_loader_get_unique_sender_id (DBusMessageLoader *loader);
typedef struct DBusInitialFDs DBusInitialFDs;
DBusInitialFDs *_dbus_check_fdleaks_enter (void);
void _dbus_check_fdleaks_leave (DBusInitialFDs *fds);
+DBusMessage * _dbus_message_remarshal(DBusMessage *message, dbus_bool_t gvariant);
+
+DBusMessage * _dbus_generate_local_error_message (dbus_uint32_t serial,
+ char *error_name,
+ char *error_msg);
+
DBUS_END_DECLS
#endif /* DBUS_MESSAGE_INTERNAL_H */
unsigned n_unix_fds_allocated; /**< Number of file descriptors this array has space for */
unsigned n_unix_fds; /**< Number of valid file descriptors in array */
#endif
+ uint64_t unique_sender_id;
};
long unix_fd_counter_delta; /**< Size we incremented the unix fd counter by */
#endif
+ DBusString *signature; /**< A placeholder for signature of received GVariant messages */
+ DBusString *unique_sender; /**< A placeholder for sender name of received GVariant messages */
};
dbus_bool_t _dbus_message_iter_get_args_valist (DBusMessageIter *iter,
*
* Copyright (C) 2002, 2003, 2004, 2005 Red Hat Inc.
* Copyright (C) 2002, 2003 CodeFactory AB
+ * Copyright (C) 2015 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
#ifdef HAVE_UNIX_FD_PASSING
#include "dbus-sysdeps-unix.h"
#endif
+#include "dbus-marshal-gvariant.h"
+#include "dbus-protocol-gvariant.h"
#include <string.h>
(type == DBUS_TYPE_STRING || type == DBUS_TYPE_SIGNATURE || \
type == DBUS_TYPE_OBJECT_PATH)
+unsigned char _dbus_default_protocol_version = DBUS_PROTOCOL_VERSION_GVARIANT;
+
static void dbus_message_finalize (DBusMessage *message);
/**
/** typedef for internals of message iterator */
typedef struct DBusMessageRealIter DBusMessageRealIter;
+#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
+
/**
* @brief Internals of DBusMessageIter
*
} u; /**< the type writer or reader that does all the work */
};
+static dbus_bool_t
+_dbus_header_is_gvariant (const DBusHeader *header)
+{
+ return (header->protocol_version == DBUS_PROTOCOL_VERSION_GVARIANT);
+}
+
+static dbus_bool_t
+_dbus_message_is_gvariant (const DBusMessage *message)
+{
+ return _dbus_header_is_gvariant (&message->header);
+}
+
static void
-get_const_signature (DBusHeader *header,
+_dbus_message_toggle_gvariant (DBusMessage *message, dbus_bool_t gvariant)
+{
+ message->header.protocol_version = gvariant ? DBUS_PROTOCOL_VERSION_GVARIANT : DBUS_MAJOR_PROTOCOL_VERSION;
+}
+
+static void
+get_const_signature (DBusMessage *message,
const DBusString **type_str_p,
int *type_pos_p)
{
- if (_dbus_header_get_field_raw (header,
- DBUS_HEADER_FIELD_SIGNATURE,
- type_str_p,
- type_pos_p))
+ dbus_bool_t got_signature = FALSE;
+ if (_dbus_message_is_gvariant (message) && message->locked)
{
- *type_pos_p += 1; /* skip the signature length which is 1 byte */
+ /* only locked GVariant messages have signatures in the body */
+ /*
+ * in case of received GVariant message, there may be no signature field in a header,
+ * but in the body. However, it is not nul-terminated.
+ * So, we need to allocate space and put it into message.
+ * It could also happen before, so check message->signature for already existing.
+ * FIXME: That may kinda break oom-safety.
+ * For now - if oom, then return empty signature.
+ */
+ if (message->signature == NULL)
+ {
+ int type_str_len;
+ got_signature = _dbus_message_gvariant_get_signature (message,
+ type_str_p,
+ type_pos_p,
+ &type_str_len);
+ if (got_signature)
+ {
+ message->signature = dbus_new (DBusString, 1);
+ got_signature = got_signature &&
+ _dbus_string_init_preallocated (message->signature, type_str_len + 1);
+
+ got_signature = got_signature &&
+ _dbus_string_copy_len (*type_str_p, *type_pos_p, type_str_len,
+ message->signature, 0);
+ got_signature = got_signature &&
+ _dbus_string_append_byte (message->signature, 0);
+ }
+ }
+ else
+ got_signature = TRUE;
+
+ if (got_signature)
+ {
+ *type_str_p = message->signature;
+ *type_pos_p = 0;
+ }
}
- else
+ else if (_dbus_header_get_field_raw (&message->header,
+ DBUS_HEADER_FIELD_SIGNATURE,
+ type_str_p,
+ type_pos_p))
+ {
+ if (!_dbus_message_is_gvariant (message))
+ *type_pos_p += 1; /* skip the signature length which is 1 byte */
+ got_signature = TRUE;
+ }
+ if (!got_signature)
{
*type_str_p = &_dbus_empty_signature_str;
*type_pos_p = 0;
_dbus_verbose ("Swapping message into compiler byte order\n");
- get_const_signature (&message->header, &type_str, &type_pos);
+ get_const_signature (message, &type_str, &type_pos);
_dbus_marshal_byteswap (type_str, type_pos,
byte_order,
{
if (!message->locked)
{
- _dbus_header_update_lengths (&message->header,
- _dbus_string_get_length (&message->body));
+ if (!_dbus_message_is_gvariant (message))
+ _dbus_header_update_lengths (&message->header,
+ _dbus_string_get_length (&message->body));
+ else
+ _dbus_message_finalize_gvariant (message, TRUE);
/* must have a signature if you have a body */
_dbus_assert (_dbus_string_get_length (&message->body) == 0 ||
close_unix_fds(message->unix_fds, &message->n_unix_fds);
#endif
+ if (NULL != message->signature)
+ {
+ _dbus_string_free (message->signature);
+ message->signature = NULL;
+ }
+
+ if (NULL != message->unique_sender)
+ {
+ _dbus_string_free (message->unique_sender);
+ message->unique_sender = NULL;
+ }
+
was_cached = FALSE;
if (!_DBUS_LOCK (message_cache))
dbus_message_set_reply_serial (DBusMessage *message,
dbus_uint32_t reply_serial)
{
+ int type = DBUS_TYPE_UINT32;
+
_dbus_return_val_if_fail (message != NULL, FALSE);
_dbus_return_val_if_fail (!message->locked, FALSE);
_dbus_return_val_if_fail (reply_serial != 0, FALSE); /* 0 is invalid */
+ if (_dbus_message_is_gvariant (message))
+ type = DBUS_TYPE_UINT64;
+
return _dbus_header_set_field_basic (&message->header,
DBUS_HEADER_FIELD_REPLY_SERIAL,
- DBUS_TYPE_UINT32,
+ type,
&reply_serial);
}
dbus_message_get_reply_serial (DBusMessage *message)
{
dbus_uint32_t v_UINT32;
+ dbus_uint64_t v_UINT64;
+ int type = DBUS_TYPE_UINT32;
+ void *value = &v_UINT32;
_dbus_return_val_if_fail (message != NULL, 0);
+ if (_dbus_message_is_gvariant (message))
+ {
+ type = DBUS_TYPE_UINT64;
+ value = &v_UINT64;
+ }
+
if (_dbus_header_get_field_basic (&message->header,
DBUS_HEADER_FIELD_REPLY_SERIAL,
- DBUS_TYPE_UINT32,
- &v_UINT32))
- return v_UINT32;
+ type,
+ value))
+ {
+ if (_dbus_message_is_gvariant (message))
+ return v_UINT64;
+ else
+ return v_UINT32;
+ }
else
return 0;
}
}
static DBusMessage*
-dbus_message_new_empty_header (void)
+dbus_message_new_empty_header (dbus_bool_t gvariant)
{
DBusMessage *message;
dbus_bool_t from_cache;
message->unix_fd_counter_delta = 0;
#endif
+ _dbus_message_toggle_gvariant (message, gvariant); /* this works only if kdbus is enabled */
+
if (!from_cache)
_dbus_data_slot_list_init (&message->slot_list);
}
}
+ message->signature = NULL;
+ message->unique_sender = NULL;
+
return message;
}
-/**
- * Constructs a new message of the given message type.
- * Types include #DBUS_MESSAGE_TYPE_METHOD_CALL,
- * #DBUS_MESSAGE_TYPE_SIGNAL, and so forth.
- *
- * Usually you want to use dbus_message_new_method_call(),
- * dbus_message_new_method_return(), dbus_message_new_signal(),
- * or dbus_message_new_error() instead.
- *
- * @param message_type type of message
- * @returns new message or #NULL if no memory
- */
-DBusMessage*
-dbus_message_new (int message_type)
+static DBusMessage*
+_dbus_message_create_protocol_version (int message_type,
+ const char *destination,
+ const char *path,
+ const char *interface,
+ const char *member,
+ const char *error_name,
+ dbus_bool_t gvariant)
{
DBusMessage *message;
- _dbus_return_val_if_fail (message_type != DBUS_MESSAGE_TYPE_INVALID, NULL);
+ _dbus_assert (message_type != DBUS_MESSAGE_TYPE_INVALID);
- message = dbus_message_new_empty_header ();
+ message = dbus_message_new_empty_header (gvariant);
if (message == NULL)
return NULL;
- if (!_dbus_header_create (&message->header,
+ if (!(_dbus_message_is_gvariant(message) ? _dbus_header_gvariant_create : _dbus_header_create) (&message->header,
DBUS_COMPILER_BYTE_ORDER,
message_type,
- NULL, NULL, NULL, NULL, NULL))
+ destination, path, interface, member, error_name))
{
dbus_message_unref (message);
return NULL;
return message;
}
+static DBusMessage*
+_dbus_message_create (int message_type,
+ const char *destination,
+ const char *path,
+ const char *interface,
+ const char *member,
+ const char *error_name)
+{
+ return _dbus_message_create_protocol_version(message_type,
+ destination,
+ path,
+ interface,
+ member,
+ error_name,
+ _dbus_default_protocol_version == DBUS_PROTOCOL_VERSION_GVARIANT);
+}
+
+/**
+ * Constructs a new message of the given message type.
+ * Types include #DBUS_MESSAGE_TYPE_METHOD_CALL,
+ * #DBUS_MESSAGE_TYPE_SIGNAL, and so forth.
+ *
+ * Usually you want to use dbus_message_new_method_call(),
+ * dbus_message_new_method_return(), dbus_message_new_signal(),
+ * or dbus_message_new_error() instead.
+ *
+ * @param message_type type of message
+ * @returns new message or #NULL if no memory
+ */
+DBusMessage*
+dbus_message_new (int message_type)
+{
+ return _dbus_message_create(message_type,
+ NULL, NULL, NULL, NULL, NULL);
+}
+
/**
* Constructs a new message to invoke a method on a remote
* object. Returns #NULL if memory can't be allocated for the
const char *iface,
const char *method)
{
- DBusMessage *message;
-
_dbus_return_val_if_fail (path != NULL, NULL);
_dbus_return_val_if_fail (method != NULL, NULL);
_dbus_return_val_if_fail (destination == NULL ||
_dbus_check_is_valid_interface (iface), NULL);
_dbus_return_val_if_fail (_dbus_check_is_valid_member (method), NULL);
- message = dbus_message_new_empty_header ();
- if (message == NULL)
- return NULL;
-
- if (!_dbus_header_create (&message->header,
- DBUS_COMPILER_BYTE_ORDER,
- DBUS_MESSAGE_TYPE_METHOD_CALL,
- destination, path, iface, method, NULL))
- {
- dbus_message_unref (message);
- return NULL;
- }
-
- return message;
+ return _dbus_message_create(DBUS_MESSAGE_TYPE_METHOD_CALL,
+ destination, path, iface, method, NULL);
}
/**
/* sender is allowed to be null here in peer-to-peer case */
- message = dbus_message_new_empty_header ();
+ message = _dbus_message_create (DBUS_MESSAGE_TYPE_METHOD_RETURN,
+ sender, NULL, NULL, NULL, NULL);
if (message == NULL)
return NULL;
- if (!_dbus_header_create (&message->header,
- DBUS_COMPILER_BYTE_ORDER,
- DBUS_MESSAGE_TYPE_METHOD_RETURN,
- sender, NULL, NULL, NULL, NULL))
- {
- dbus_message_unref (message);
- return NULL;
- }
-
dbus_message_set_no_reply (message, TRUE);
if (!dbus_message_set_reply_serial (message,
_dbus_return_val_if_fail (_dbus_check_is_valid_interface (iface), NULL);
_dbus_return_val_if_fail (_dbus_check_is_valid_member (name), NULL);
- message = dbus_message_new_empty_header ();
+ message = _dbus_message_create (DBUS_MESSAGE_TYPE_SIGNAL,
+ NULL, path, iface, name, NULL);
if (message == NULL)
return NULL;
- if (!_dbus_header_create (&message->header,
- DBUS_COMPILER_BYTE_ORDER,
- DBUS_MESSAGE_TYPE_SIGNAL,
- NULL, path, iface, name, NULL))
- {
- dbus_message_unref (message);
- return NULL;
- }
-
dbus_message_set_no_reply (message, TRUE);
return message;
* when the message bus is dealing with an unregistered
* connection.
*/
- message = dbus_message_new_empty_header ();
+ message = _dbus_message_create (DBUS_MESSAGE_TYPE_ERROR,
+ sender, NULL, NULL, NULL, error_name);
if (message == NULL)
return NULL;
- if (!_dbus_header_create (&message->header,
- DBUS_COMPILER_BYTE_ORDER,
- DBUS_MESSAGE_TYPE_ERROR,
- sender, NULL, NULL, NULL, error_name))
- {
- dbus_message_unref (message);
- return NULL;
- }
-
dbus_message_set_no_reply (message, TRUE);
if (!dbus_message_set_reply_serial (message,
#ifndef DBUS_DISABLE_CHECKS
retval->generation = message->generation;
#endif
+ _dbus_message_toggle_gvariant (retval, _dbus_message_is_gvariant (message));
if (!_dbus_header_copy (&message->header, &retval->header))
{
const DBusString *type_str;
int type_pos;
+ BUILD_BUG_ON (sizeof(DBusMessageIter) != sizeof(DBusMessageRealIter));
+
_dbus_return_val_if_fail (message != NULL, FALSE);
_dbus_return_val_if_fail (iter != NULL, FALSE);
- get_const_signature (&message->header, &type_str, &type_pos);
+ get_const_signature (message, &type_str, &type_pos);
_dbus_message_iter_init_common (message, real,
DBUS_MESSAGE_ITER_TYPE_READER);
_dbus_type_reader_init (&real->u.reader,
- _dbus_header_get_byte_order (&message->header),
- type_str, type_pos,
- &message->body,
- 0);
+ _dbus_header_get_byte_order (&message->header),
+ type_str, type_pos,
+ &message->body,
+ 0);
+
+ if (_dbus_message_is_gvariant (message))
+ _dbus_type_reader_gvariant_init (&real->u.reader, message);
return _dbus_type_reader_get_current_type (&real->u.reader) != DBUS_TYPE_INVALID;
}
* when a value is actually appended. That means that init() never fails
* due to OOM.
*/
- _dbus_type_writer_init_types_delayed (&real->u.writer,
- _dbus_header_get_byte_order (&message->header),
- &message->body,
- _dbus_string_get_length (&message->body));
+ _dbus_type_writer_gvariant_init_types_delayed (
+ &real->u.writer,
+ _dbus_header_get_byte_order (&message->header),
+ &message->body,
+ _dbus_string_get_length (&message->body),
+ _dbus_message_is_gvariant (message));
}
/**
if (current_sig)
{
int current_len;
+ int additional_size_for_len = 0;
- current_len = _dbus_string_get_byte (current_sig, current_sig_pos);
- current_sig_pos += 1; /* move on to sig data */
+ if (!real->u.writer.gvariant)
+ {
+ current_len = _dbus_string_get_byte (current_sig, current_sig_pos);
+ current_sig_pos += 1; /* move on to sig data */
+ additional_size_for_len = 4;
+ }
+ else
+ {
+ /* GVariant has no length field, simply string */
+ current_len = strlen (_dbus_string_get_const_data (current_sig) + current_sig_pos);
+ }
- if (!_dbus_string_init_preallocated (str, current_len + 4))
+ if (!_dbus_string_init_preallocated (str, current_len + additional_size_for_len))
{
dbus_free (str);
return FALSE;
_dbus_return_val_if_fail (message != NULL, NULL);
+ if (NULL != message->unique_sender)
+ return _dbus_string_get_const_data (message->unique_sender);
+
v = NULL; /* in case field doesn't exist */
_dbus_header_get_field_basic (&message->header,
DBUS_HEADER_FIELD_SENDER,
_dbus_return_val_if_fail (message != NULL, NULL);
- get_const_signature (&message->header, &type_str, &type_pos);
+ get_const_signature (message, &type_str, &type_pos);
return _dbus_string_get_const_data_len (type_str, type_pos, 0);
}
/* 2. VALIDATE BODY */
if (mode != DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY)
{
- get_const_signature (&message->header, &type_str, &type_pos);
-
- /* Because the bytes_remaining arg is NULL, this validates that the
- * body is the right length
- */
- validity = _dbus_validate_body_with_reason (type_str,
- type_pos,
- byte_order,
- NULL,
- &loader->data,
- header_len,
- body_len);
+ if (_dbus_message_is_gvariant (message))
+ {
+ validity = _dbus_validate_gvariant_body_with_reason (type_str,
+ type_pos,
+ byte_order,
+ NULL,
+ &loader->data,
+ header_len,
+ body_len);
+ }
+ else
+ {
+
+ get_const_signature (message, &type_str, &type_pos);
+
+ /* Because the bytes_remaining arg is NULL, this validates that the
+ * body is the right length
+ */
+
+ validity = _dbus_validate_body_with_reason (type_str,
+ type_pos,
+ byte_order,
+ NULL,
+ &loader->data,
+ header_len,
+ body_len);
+ }
if (validity != DBUS_VALID)
{
_dbus_verbose ("Failed to validate message body code %d\n", validity);
return FALSE;
}
+static dbus_bool_t
+set_unique_sender (DBusMessage *message, uint64_t unique_sender_id)
+{
+ if (NULL == message->unique_sender)
+ {
+ message->unique_sender = dbus_new (DBusString, 1);
+ if (NULL == message->unique_sender)
+ return FALSE;
+
+ if (!_dbus_string_init (message->unique_sender))
+ return FALSE;
+ }
+
+ _dbus_string_set_length (message->unique_sender, 0);
+
+ if (!_dbus_string_append_printf (message->unique_sender, ":1.%llu", (unsigned long long)unique_sender_id))
+ {
+ _dbus_string_free (message->unique_sender);
+ message->unique_sender = NULL;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
/**
* Converts buffered data into messages, if we have enough data. If
* we don't have enough data, does nothing.
{
DBusValidity validity;
int byte_order, fields_array_len, header_len, body_len;
+ dbus_bool_t is_gvariant;
if (_dbus_header_have_message_untrusted (loader->max_message_size,
&validity,
&header_len,
&body_len,
&loader->data, 0,
- _dbus_string_get_length (&loader->data)))
+ _dbus_string_get_length (&loader->data),
+ &is_gvariant))
{
DBusMessage *message;
_dbus_assert (validity == DBUS_VALID);
- message = dbus_message_new_empty_header ();
+ message = dbus_message_new_empty_header (is_gvariant);
if (message == NULL)
return FALSE;
return loader->corrupted;
}
+ if (_dbus_message_is_gvariant (message))
+ {
+ set_unique_sender (message, _dbus_message_loader_get_unique_sender_id (loader));
+ message->locked = TRUE;
+ }
+
_dbus_assert (loader->messages != NULL);
_dbus_assert (_dbus_list_find_last (&loader->messages, message) != NULL);
}
return loader->max_message_unix_fds;
}
+void _dbus_message_loader_set_unique_sender_id (DBusMessageLoader *loader,
+ uint64_t id)
+{
+ loader->unique_sender_id = id;
+}
+
+uint64_t _dbus_message_loader_get_unique_sender_id (DBusMessageLoader *loader)
+{
+ return loader->unique_sender_id;
+}
+
static DBusDataSlotAllocator slot_allocator =
_DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (message_slots));
int byte_order, fields_array_len, header_len, body_len;
DBusValidity validity = DBUS_VALID;
int have_message;
+ dbus_bool_t is_gvariant;
if (!buf || len < DBUS_MINIMUM_HEADER_SIZE)
return 0;
&header_len,
&body_len,
&str, 0,
- len);
+ len,
+ &is_gvariant);
_dbus_string_free (&str);
if (validity == DBUS_VALID)
}
}
+static dbus_bool_t
+_dbus_message_copy_recursive(DBusMessageIter *iter, DBusMessageIter *dest)
+{
+ dbus_bool_t res = TRUE;
+ int current_type;
+
+ while ((current_type = dbus_message_iter_get_arg_type (iter)) != DBUS_TYPE_INVALID) {
+ if (dbus_type_is_basic(current_type)) {
+ DBusBasicValue value;
+ dbus_message_iter_get_basic (iter, &value);
+ dbus_message_iter_append_basic (dest, current_type, &value);
+ }
+ else {
+ DBusMessageIter sub;
+ DBusMessageIter dest_sub;
+ char *sig = NULL;
+
+ dbus_message_iter_recurse (iter, &sub);
+ if (DBUS_TYPE_VARIANT == current_type)
+ sig = dbus_message_iter_get_signature (&sub);
+ else if (DBUS_TYPE_ARRAY == current_type)
+ sig = dbus_message_iter_get_signature (&sub);
+
+ res = res && dbus_message_iter_open_container (dest, current_type, sig, &dest_sub);
+ dbus_free(sig);
+ res = res && _dbus_message_copy_recursive (&sub, &dest_sub);
+ res = res && dbus_message_iter_close_container (dest, &dest_sub);
+
+ if (!res) {
+ return FALSE;
+ }
+ }
+
+ dbus_message_iter_next (iter);
+ }
+
+ return TRUE;
+}
+
+DBusMessage *
+_dbus_message_remarshal (DBusMessage *message, dbus_bool_t gvariant)
+{
+ DBusMessage *ret;
+ DBusMessageIter iter, ret_iter;
+ int i;
+ dbus_uint32_t serial;
+ const char *sender;
+
+ _dbus_assert (message->locked);
+
+ ret = _dbus_message_create_protocol_version (dbus_message_get_type(message),
+ dbus_message_get_destination(message),
+ dbus_message_get_path(message),
+ dbus_message_get_interface(message),
+ dbus_message_get_member(message),
+ dbus_message_get_error_name(message),
+ gvariant);
+
+ dbus_message_iter_init (message, &iter);
+ dbus_message_iter_init_append (ret, &ret_iter);
+ if (!_dbus_message_copy_recursive(&iter, &ret_iter))
+ return NULL;
+
+#ifdef HAVE_UNIX_FD_PASSING
+ ret->unix_fds = dbus_new(int, message->n_unix_fds);
+ if (ret->unix_fds == NULL && message->n_unix_fds > 0)
+ goto err;
+
+ ret->n_unix_fds_allocated = message->n_unix_fds;
+
+ for (i = 0; i < message->n_unix_fds; ++i) {
+ ret->unix_fds[i] = _dbus_dup(message->unix_fds[i], NULL);
+
+ if (ret->unix_fds[i] < 0)
+ goto err;
+ }
+
+ ret->n_unix_fds = message->n_unix_fds;
+#endif
+
+ /* Remarshal data in header:
+ byte order (already set)
+ type (already set)
+ flags - only those we understand
+ version (already set)
+ body length
+ serial
+ fields array (length)
+ fields:
+ path (already set)
+ interface (already set)
+ member (already set)
+ error name (already set)
+ reply serial
+ destination (already set)
+ sender
+ signature (set during copy, but an action needed for conversion to GVariant)
+ unix fds
+ */
+
+ /* FLAGS */
+ _dbus_header_toggle_flag (&ret->header, DBUS_HEADER_FLAG_NO_REPLY_EXPECTED,
+ _dbus_header_get_flag (&message->header, DBUS_HEADER_FLAG_NO_REPLY_EXPECTED));
+
+ _dbus_header_toggle_flag (&ret->header, DBUS_HEADER_FLAG_NO_AUTO_START,
+ _dbus_header_get_flag (&message->header, DBUS_HEADER_FLAG_NO_AUTO_START));
+
+ /* SERIAL / COOKIE */
+ serial = dbus_message_get_serial (message);
+
+ if (0 != serial)
+ dbus_message_set_serial (ret, serial);
+
+ /* Field: REPLY_SERIAL */
+ serial = dbus_message_get_reply_serial (message);
+
+ if (0 != serial && !dbus_message_set_reply_serial (ret, serial))
+ goto err;
+
+ /* Field: SENDER */
+ sender = dbus_message_get_sender (message);
+
+ if (NULL != sender && !dbus_message_set_sender (ret, sender))
+ goto err;
+
+ /* BODY LENGTH */
+ if (!gvariant)
+ _dbus_header_update_lengths (&ret->header,
+ _dbus_string_get_length (&ret->body));
+ /* For GVariant: */
+ /* Field: SIGNATURE to body; add body offset - this is done with dbus_message_lock() */
+
+ return ret;
+
+err:
+ _dbus_header_free (&ret->header);
+ _dbus_string_free (&ret->body);
+
+#ifdef HAVE_UNIX_FD_PASSING
+ close_unix_fds(ret->unix_fds, &ret->n_unix_fds);
+ dbus_free(ret->unix_fds);
+#endif
+
+ return NULL;
+}
+
+void
+dbus_set_protocol_version (unsigned char version)
+{
+ _dbus_default_protocol_version = version;
+}
+
+DBusMessage *
+_dbus_generate_local_error_message (dbus_uint32_t serial,
+ char *error_name,
+ char *error_msg)
+{
+ DBusMessage *message;
+ message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
+ if (!message)
+ goto out;
+
+ if (!dbus_message_set_error_name (message, error_name))
+ {
+ dbus_message_unref (message);
+ message = NULL;
+ goto out;
+ }
+
+ dbus_message_set_no_reply (message, TRUE);
+
+ if (!dbus_message_set_reply_serial (message,
+ serial))
+ {
+ dbus_message_unref (message);
+ message = NULL;
+ goto out;
+ }
+
+ if (error_msg != NULL)
+ {
+ DBusMessageIter iter;
+
+ dbus_message_iter_init_append (message, &iter);
+ if (!dbus_message_iter_append_basic (&iter,
+ DBUS_TYPE_STRING,
+ &error_msg))
+ {
+ dbus_message_unref (message);
+ message = NULL;
+ goto out;
+ }
+ }
+
+ out:
+ return message;
+}
+
/** @} */
/* tests in dbus-message-util.c */
/* dbus-message.h DBusMessage object
*
* Copyright (C) 2002, 2003, 2005 Red Hat Inc.
+ * Copyright (C) 2015 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
* DBusMessageIter struct; contains no public fields.
*/
struct DBusMessageIter
-{
- void *dummy1; /**< Don't use this */
- void *dummy2; /**< Don't use this */
- dbus_uint32_t dummy3; /**< Don't use this */
- int dummy4; /**< Don't use this */
- int dummy5; /**< Don't use this */
- int dummy6; /**< Don't use this */
- int dummy7; /**< Don't use this */
- int dummy8; /**< Don't use this */
- int dummy9; /**< Don't use this */
- int dummy10; /**< Don't use this */
- int dummy11; /**< Don't use this */
- int pad1; /**< Don't use this */
- int pad2; /**< Don't use this */
- void *pad3; /**< Don't use this */
+{ /* layout on a standard 64-bit system */
+ void *dummy1; /**< Don't use this */ /* message */
+ dbus_uint32_t dummy3; /**< Don't use this */ /* changed_stamp, iter_type, sig_refcount */
+
+ /* padding before union */
+ /* below is union */
+ /* reader on the left, writer on the right */
+ struct {
+ dbus_uint32_t dummy4; /**< Don't use this */ /* bitfields */ /* bitfields */
+ /* padding before pointer */
+ void *dummy5; /**< Don't use this */ /* type_str */ /* type_str */
+ int dummy6; /**< Don't use this */ /* type_pos */ /* type_pos */
+ /* padding before pointer */
+ void *dummy7; /**< Don't use this */ /* value_str */ /* value_str */
+ int dummy8; /**< Don't use this */ /* value_pos */ /* value_pos */
+ int dummy9; /**< Don't use this */ /* variable_index */ /* padding */
+ size_t dummy10; /**< Don't use this */ /* value_start */ /* value_start */
+ size_t dummy11; /**< Don't use this */ /* value_end */ /* u.array.start_pos */
+ /* u.array.len_pos */
+ int dummy12; /**< Don't use this */ /* n_offsets */ /* u.array.element_type_pos*/
+ void *dummy13; /**< Don't use this */ /* klass */ /* u.array.offsets_size */
+ struct {
+ int dummy14; /**< Don't use this */ /* u.array.start_pos */
+ } dummy_u;
+ } dummy_u;
};
DBUS_EXPORT
int dbus_message_demarshal_bytes_needed (const char *str,
int len);
+DBUS_EXPORT
+void dbus_set_protocol_version (unsigned char version);
+
/** @} */
DBUS_END_DECLS
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-protocol.h D-Bus protocol constants
+ *
+ * Copyright (C) 2015 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef DBUS_PROTOCOL_GVARIANT_H
+#define DBUS_PROTOCOL_GVARIANT_H
+
+#define DBUS_PROTOCOL_VERSION_GVARIANT 2
+
+/** Header format is defined as a signature:
+ * byte byte order
+ * byte message type ID
+ * byte flags
+ * byte protocol version
+ * uint64 cookie
+ * array of dict entries (uint64,variant) (field name, value)
+ *
+ * The length of the header can be computed as the
+ * fixed size of the initial data, plus the length of
+ * the array at the end, plus padding to an 8-boundary.
+ */
+#define DBUS_HEADER_GVARIANT_SIGNATURE \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_UINT64_AS_STRING \
+ DBUS_TYPE_ARRAY_AS_STRING \
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_VARIANT_AS_STRING \
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING \
+ DBUS_TYPE_VARIANT_AS_STRING
+
+#define FIRST_GVARIANT_FIELD_OFFSET 16 /* yyyyut is before a{tv}*/
+
+#endif /* DBUS_PROTOCOL_GVARIANT_H */
#define DBUS_START_REPLY_SUCCESS 1 /**< Service was auto started */
#define DBUS_START_REPLY_ALREADY_RUNNING 2 /**< Service was already running */
+#define DBUS_ADDRESS_KDBUS "kernel:"
+
/** @} */
#ifdef __cplusplus
--- /dev/null
+/* signals.c Bus signal connection implementation
+ *
+ * Copyright (C) 2003, 2005 Red Hat, Inc.
+ * Copyright 2014 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include "../config.h"
+#include "dbus-signals.h"
+#include <dbus/dbus-marshal-validate.h>
+#include "dbus-internals.h"
+#include "dbus-hash.h"
+#include "dbus-list.h"
+#include "kdbus-common.h"
+#include <stdlib.h>
+#include <limits.h>
+
+#define SET_OOM(error) dbus_set_error_const ((error), DBUS_ERROR_NO_MEMORY, "Memory allocation failure in transport, regarding match rules")
+
+struct MatchRule
+{
+ int refcount; /**< reference count */
+
+ DBusConnection *matches_go_to; /**< Owner of the rule */
+
+ unsigned int flags; /**< MatchFlags */
+
+ int message_type;
+ char *interface;
+ char *member;
+ char *sender;
+ char *destination;
+ char *path;
+
+ unsigned int *arg_lens;
+ char **args;
+ int args_len;
+
+ __u64 kdbus_cookie;
+};
+
+#define MATCH_ARG_FLAGS (MATCH_ARG_NAMESPACE |MATCH_ARG_IS_PATH)
+
+static MatchRule*
+bus_match_rule_new (DBusConnection *matches_go_to)
+{
+ MatchRule *rule;
+
+ rule = dbus_new0 (MatchRule, 1);
+ if (rule == NULL)
+ return NULL;
+
+ rule->refcount = 1;
+ rule->matches_go_to = matches_go_to;
+ rule->kdbus_cookie = 0;
+
+#ifndef DBUS_ENABLE_EMBEDDED_TESTS
+ _dbus_assert (rule->matches_go_to != NULL);
+#endif
+
+ return rule;
+}
+
+static MatchRule *
+bus_match_rule_ref (MatchRule *rule)
+{
+ _dbus_assert (rule->refcount > 0);
+
+ rule->refcount += 1;
+
+ return rule;
+}
+
+void
+match_rule_unref (MatchRule *rule)
+{
+ _dbus_assert (rule->refcount > 0);
+
+ rule->refcount -= 1;
+ if (rule->refcount == 0)
+ {
+ dbus_free (rule->interface);
+ dbus_free (rule->member);
+ dbus_free (rule->sender);
+ dbus_free (rule->destination);
+ dbus_free (rule->path);
+ dbus_free (rule->arg_lens);
+
+ /* can't use dbus_free_string_array() since there
+ * are embedded NULL
+ */
+ if (rule->args)
+ {
+ int i;
+
+ i = 0;
+ while (i < rule->args_len)
+ {
+ if (rule->args[i])
+ dbus_free (rule->args[i]);
+ ++i;
+ }
+
+ dbus_free (rule->args);
+ }
+
+ dbus_free (rule);
+ }
+}
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+/* Note this function does not do escaping, so it's only
+ * good for debug spew at the moment
+ */
+char*
+match_rule_to_string (MatchRule *rule)
+{
+ DBusString str;
+ char *ret;
+
+ if (!_dbus_string_init (&str))
+ {
+ char *s;
+ while ((s = _dbus_strdup ("nomem")) == NULL)
+ ; /* only OK for debug spew... */
+ return s;
+ }
+
+ if (rule->flags & MATCH_MESSAGE_TYPE)
+ {
+ if (!_dbus_string_append_printf (&str, "type='%s'",
+ dbus_message_type_to_string (rule->message_type)))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_INTERFACE)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_MEMBER)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "member='%s'", rule->member))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_PATH)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "path='%s'", rule->path))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_PATH_NAMESPACE)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "path_namespace='%s'", rule->path))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_SENDER)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_DESTINATION)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination))
+ goto nomem;
+ }
+
+ if (rule->flags & MATCH_CLIENT_IS_EAVESDROPPING)
+ {
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ if (!_dbus_string_append_printf (&str, "eavesdrop='%s'",
+ (rule->flags & MATCH_CLIENT_IS_EAVESDROPPING) ?
+ "true" : "false"))
+ goto nomem;
+ }
+
+ if (rule->flags &MATCH_ARGS)
+ {
+ int i;
+
+ _dbus_assert (rule->args != NULL);
+
+ i = 0;
+ while (i < rule->args_len)
+ {
+ if (rule->args[i] != NULL)
+ {
+ dbus_bool_t is_path, is_namespace;
+
+ if (_dbus_string_get_length (&str) > 0)
+ {
+ if (!_dbus_string_append (&str, ","))
+ goto nomem;
+ }
+
+ is_path = (rule->arg_lens[i] & MATCH_ARG_IS_PATH) != 0;
+ is_namespace = (rule->arg_lens[i] & MATCH_ARG_NAMESPACE) != 0;
+
+ if (!_dbus_string_append_printf (&str,
+ "arg%d%s='%s'",
+ i,
+ is_path ? "path" :
+ is_namespace ? "namespace" : "",
+ rule->args[i]))
+ goto nomem;
+ }
+
+ ++i;
+ }
+ }
+
+ if (!_dbus_string_steal_data (&str, &ret))
+ goto nomem;
+
+ _dbus_string_free (&str);
+ return ret;
+
+ nomem:
+ _dbus_string_free (&str);
+ {
+ char *s;
+ while ((s = _dbus_strdup ("nomem")) == NULL)
+ ; /* only OK for debug spew... */
+ return s;
+ }
+}
+#endif /* DBUS_ENABLE_VERBOSE_MODE */
+
+static dbus_bool_t
+bus_match_rule_set_message_type (MatchRule *rule,
+ int type)
+{
+ rule->flags |=MATCH_MESSAGE_TYPE;
+
+ rule->message_type = type;
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_match_rule_set_interface (MatchRule *rule,
+ const char *interface)
+{
+ char *new;
+
+ _dbus_assert (interface != NULL);
+
+ new = _dbus_strdup (interface);
+ if (new == NULL)
+ return FALSE;
+
+ rule->flags |=MATCH_INTERFACE;
+ dbus_free (rule->interface);
+ rule->interface = new;
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_match_rule_set_member (MatchRule *rule,
+ const char *member)
+{
+ char *new;
+
+ _dbus_assert (member != NULL);
+
+ new = _dbus_strdup (member);
+ if (new == NULL)
+ return FALSE;
+
+ rule->flags |=MATCH_MEMBER;
+ dbus_free (rule->member);
+ rule->member = new;
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_match_rule_set_sender (MatchRule *rule,
+ const char *sender)
+{
+ char *new;
+
+ _dbus_assert (sender != NULL);
+
+ new = _dbus_strdup (sender);
+ if (new == NULL)
+ return FALSE;
+
+ rule->flags |=MATCH_SENDER;
+ dbus_free (rule->sender);
+ rule->sender = new;
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_match_rule_set_destination (MatchRule *rule,
+ const char *destination)
+{
+ char *new;
+
+ _dbus_assert (destination != NULL);
+
+ new = _dbus_strdup (destination);
+ if (new == NULL)
+ return FALSE;
+
+ rule->flags |=MATCH_DESTINATION;
+ dbus_free (rule->destination);
+ rule->destination = new;
+
+ return TRUE;
+}
+
+static void
+bus_match_rule_set_client_is_eavesdropping (MatchRule *rule,
+ dbus_bool_t is_eavesdropping)
+{
+ if (is_eavesdropping)
+ rule->flags |= MATCH_CLIENT_IS_EAVESDROPPING;
+ else
+ rule->flags &= ~(MATCH_CLIENT_IS_EAVESDROPPING);
+}
+
+static dbus_bool_t
+bus_match_rule_set_path (MatchRule *rule,
+ const char *path,
+ dbus_bool_t is_namespace)
+{
+ char *new;
+
+ _dbus_assert (path != NULL);
+
+ new = _dbus_strdup (path);
+ if (new == NULL)
+ return FALSE;
+
+ rule->flags &= ~(MATCH_PATH | MATCH_PATH_NAMESPACE);
+
+ if (is_namespace)
+ rule->flags |= MATCH_PATH_NAMESPACE;
+ else
+ rule->flags |= MATCH_PATH;
+
+ dbus_free (rule->path);
+ rule->path = new;
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_match_rule_set_arg (MatchRule *rule,
+ int arg,
+ const DBusString *value,
+ dbus_bool_t is_path,
+ dbus_bool_t is_namespace)
+{
+ int length;
+ char *new;
+
+ _dbus_assert (value != NULL);
+
+ /* args_len is the number of args not including null termination
+ * in the char**
+ */
+ if (arg >= rule->args_len)
+ {
+ unsigned int *new_arg_lens;
+ char **new_args;
+ int new_args_len;
+ int i;
+
+ new_args_len = arg + 1;
+
+ /* add another + 1 here for null termination */
+ new_args = dbus_realloc (rule->args,
+ sizeof (char *) * (new_args_len + 1));
+ if (new_args == NULL)
+ return FALSE;
+
+ /* NULL the new slots */
+ i = rule->args_len;
+ while (i <= new_args_len) /* <= for null termination */
+ {
+ new_args[i] = NULL;
+ ++i;
+ }
+
+ rule->args = new_args;
+
+ /* and now add to the lengths */
+ new_arg_lens = dbus_realloc (rule->arg_lens,
+ sizeof (int) * (new_args_len + 1));
+
+ if (new_arg_lens == NULL)
+ return FALSE;
+
+ /* zero the new slots */
+ i = rule->args_len;
+ while (i <= new_args_len) /* <= for null termination */
+ {
+ new_arg_lens[i] = 0;
+ ++i;
+ }
+
+ rule->arg_lens = new_arg_lens;
+ rule->args_len = new_args_len;
+ }
+
+ length = _dbus_string_get_length (value);
+ if (!_dbus_string_copy_data (value, &new))
+ return FALSE;
+
+ rule->flags |=MATCH_ARGS;
+
+ dbus_free (rule->args[arg]);
+ rule->arg_lens[arg] = length;
+ rule->args[arg] = new;
+
+ if (is_path)
+ rule->arg_lens[arg] |=MATCH_ARG_IS_PATH;
+
+ if (is_namespace)
+ rule->arg_lens[arg] |=MATCH_ARG_NAMESPACE;
+
+ /* NULL termination didn't get busted */
+ _dbus_assert (rule->args[rule->args_len] == NULL);
+ _dbus_assert (rule->arg_lens[rule->args_len] == 0);
+
+ return TRUE;
+}
+
+void
+match_rule_set_cookie (MatchRule *rule, dbus_uint64_t cookie)
+{
+ rule->kdbus_cookie = cookie;
+}
+
+dbus_uint64_t
+match_rule_get_cookie (MatchRule *rule)
+{
+ return rule->kdbus_cookie;
+}
+
+#define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
+
+static dbus_bool_t
+find_key (const DBusString *str,
+ int start,
+ DBusString *key,
+ int *value_pos,
+ DBusError *error)
+{
+ const char *p;
+ const char *s;
+ const char *key_start;
+ const char *key_end;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ s = _dbus_string_get_const_data (str);
+
+ p = s + start;
+
+ while (*p && ISWHITE (*p))
+ ++p;
+
+ key_start = p;
+
+ while (*p && *p != '=' && !ISWHITE (*p))
+ ++p;
+
+ key_end = p;
+
+ while (*p && ISWHITE (*p))
+ ++p;
+
+ if (key_start == key_end)
+ {
+ /* Empty match rules or trailing whitespace are OK */
+ *value_pos = p - s;
+ return TRUE;
+ }
+
+ if (*p != '=')
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Match rule has a key with no subsequent '=' character");
+ return FALSE;
+ }
+ ++p;
+
+ if (!_dbus_string_append_len (key, key_start, key_end - key_start))
+ {
+ SET_OOM (error);
+ return FALSE;
+ }
+
+ *value_pos = p - s;
+
+ return TRUE;
+}
+
+static dbus_bool_t
+find_value (const DBusString *str,
+ int start,
+ const char *key,
+ DBusString *value,
+ int *value_end,
+ DBusError *error)
+{
+ const char *p;
+ const char *s;
+ char quote_char;
+ int orig_len;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ orig_len = _dbus_string_get_length (value);
+
+ s = _dbus_string_get_const_data (str);
+
+ p = s + start;
+
+ quote_char = '\0';
+
+ while (*p)
+ {
+ if (quote_char == '\0')
+ {
+ switch (*p)
+ {
+ case '\0':
+ goto done;
+
+ case '\'':
+ quote_char = '\'';
+ goto next;
+
+ case ',':
+ ++p;
+ goto done;
+
+ case '\\':
+ quote_char = '\\';
+ goto next;
+
+ default:
+ if (!_dbus_string_append_byte (value, *p))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ }
+ else if (quote_char == '\\')
+ {
+ /* \ only counts as an escape if escaping a quote mark */
+ if (*p != '\'')
+ {
+ if (!_dbus_string_append_byte (value, '\\'))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+
+ if (!_dbus_string_append_byte (value, *p))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+
+ quote_char = '\0';
+ }
+ else
+ {
+ _dbus_assert (quote_char == '\'');
+
+ if (*p == '\'')
+ {
+ quote_char = '\0';
+ }
+ else
+ {
+ if (!_dbus_string_append_byte (value, *p))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ }
+
+ next:
+ ++p;
+ }
+
+ done:
+
+ if (quote_char == '\\')
+ {
+ if (!_dbus_string_append_byte (value, '\\'))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (quote_char == '\'')
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Unbalanced quotation marks in match rule");
+ goto failed;
+ }
+ else
+ _dbus_assert (quote_char == '\0');
+
+ /* Zero-length values are allowed */
+
+ *value_end = p - s;
+
+ return TRUE;
+
+ failed:
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ _dbus_string_set_length (value, orig_len);
+ return FALSE;
+}
+
+/* duplicates aren't allowed so the real legitimate max is only 6 or
+ * so. Leaving extra so we don't have to bother to update it.
+ * FIXME this is sort of busted now with arg matching, but we let
+ * you match on up to 10 args for now
+ */
+#define MAX_RULE_TOKENS 16
+
+/* this is slightly too high level to be termed a "token"
+ * but let's not be pedantic.
+ */
+typedef struct
+{
+ char *key;
+ char *value;
+} RuleToken;
+
+static dbus_bool_t
+tokenize_rule (const DBusString *rule_text,
+ RuleToken tokens[MAX_RULE_TOKENS],
+ DBusError *error)
+{
+ int i;
+ int pos;
+ DBusString key;
+ DBusString value;
+ dbus_bool_t retval;
+
+ retval = FALSE;
+
+ if (!_dbus_string_init (&key))
+ {
+ SET_OOM (error);
+ return FALSE;
+ }
+
+ if (!_dbus_string_init (&value))
+ {
+ _dbus_string_free (&key);
+ SET_OOM (error);
+ return FALSE;
+ }
+
+ i = 0;
+ pos = 0;
+ while (i < MAX_RULE_TOKENS &&
+ pos < _dbus_string_get_length (rule_text))
+ {
+ _dbus_assert (tokens[i].key == NULL);
+ _dbus_assert (tokens[i].value == NULL);
+
+ if (!find_key (rule_text, pos, &key, &pos, error))
+ goto out;
+
+ if (_dbus_string_get_length (&key) == 0)
+ goto next;
+
+ if (!_dbus_string_steal_data (&key, &tokens[i].key))
+ {
+ SET_OOM (error);
+ goto out;
+ }
+
+ if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error))
+ goto out;
+
+ if (!_dbus_string_steal_data (&value, &tokens[i].value))
+ {
+ SET_OOM (error);
+ goto out;
+ }
+
+ next:
+ ++i;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (!retval)
+ {
+ i = 0;
+ while (tokens[i].key || tokens[i].value)
+ {
+ dbus_free (tokens[i].key);
+ dbus_free (tokens[i].value);
+ tokens[i].key = NULL;
+ tokens[i].value = NULL;
+ ++i;
+ }
+ }
+
+ _dbus_string_free (&key);
+ _dbus_string_free (&value);
+
+ return retval;
+}
+
+static dbus_bool_t
+bus_match_rule_parse_arg_match (MatchRule *rule,
+ const char *key,
+ const DBusString *value,
+ DBusError *error)
+{
+ dbus_bool_t is_path = FALSE;
+ dbus_bool_t is_namespace = FALSE;
+ DBusString key_str;
+ unsigned long arg;
+ int length;
+ int end;
+
+ /* For now, arg0='foo' always implies that 'foo' is a
+ * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing
+ * if we wanted, which would specify another type, in which case
+ * arg0='5' would have the 5 parsed as an int rather than string.
+ */
+
+ /* First we need to parse arg0 = 0, arg27 = 27 */
+
+ _dbus_string_init_const (&key_str, key);
+ length = _dbus_string_get_length (&key_str);
+
+ if (_dbus_string_get_length (&key_str) < 4)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key);
+ goto failed;
+ }
+
+ if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key);
+ goto failed;
+ }
+
+ if (end != length)
+ {
+ if ((end + strlen ("path")) == length &&
+ _dbus_string_ends_with_c_str (&key_str, "path"))
+ {
+ is_path = TRUE;
+ }
+ else if (_dbus_string_equal_c_str (&key_str, "arg0namespace"))
+ {
+ int value_len = _dbus_string_get_length (value);
+
+ is_namespace = TRUE;
+
+ if (!_dbus_validate_bus_namespace (value, 0, value_len))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "arg0namespace='%s' is not a valid prefix of a bus name",
+ _dbus_string_get_const_data (value));
+ goto failed;
+ }
+ }
+ else
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key '%s' in match rule contains junk after argument number (%u). Only 'arg%upath' (for example) or 'arg0namespace' are valid", key, arg, arg);
+ goto failed;
+ }
+ }
+
+ /* If we didn't check this we could allocate a huge amount of RAM */
+ if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key '%s' in match rule has arg number %lu but the maximum is %d.\n", key, (unsigned long) arg, DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER);
+ goto failed;
+ }
+
+ if ((rule->flags &MATCH_ARGS) &&
+ rule->args_len > (int) arg &&
+ rule->args[arg] != NULL)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Argument %d matched more than once in match rule\n", key);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_arg (rule, arg, value, is_path, is_namespace))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+
+ return TRUE;
+
+ failed:
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return FALSE;
+}
+
+/*
+ * The format is comma-separated with strings quoted with single quotes
+ * as for the shell (to escape a literal single quote, use '\'').
+ *
+ * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',
+ * path='/bar/foo',destination=':452345.34'
+ *
+ */
+MatchRule*
+match_rule_parse (DBusConnection *matches_go_to,
+ const DBusString *rule_text,
+ DBusError *error)
+{
+ MatchRule *rule;
+ RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */
+ int i;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)
+ {
+ dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
+ "Match rule text is %d bytes, maximum is %d",
+ _dbus_string_get_length (rule_text),
+ DBUS_MAXIMUM_MATCH_RULE_LENGTH);
+ return NULL;
+ }
+
+ memset (tokens, '\0', sizeof (tokens));
+
+ rule = bus_match_rule_new (matches_go_to);
+ if (rule == NULL)
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+
+ if (!tokenize_rule (rule_text, tokens, error))
+ goto failed;
+
+ i = 0;
+ while (tokens[i].key != NULL)
+ {
+ DBusString tmp_str;
+ int len;
+ const char *key = tokens[i].key;
+ const char *value = tokens[i].value;
+
+ _dbus_string_init_const (&tmp_str, value);
+ len = _dbus_string_get_length (&tmp_str);
+
+ if (strcmp (key, "type") == 0)
+ {
+ int t;
+
+ if (rule->flags & MATCH_MESSAGE_TYPE)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key %s specified twice in match rule\n", key);
+ goto failed;
+ }
+
+ t = dbus_message_type_from_string (value);
+
+ if (t == DBUS_MESSAGE_TYPE_INVALID)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Invalid message type (%s) in match rule\n", value);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_message_type (rule, t))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (strcmp (key, "sender") == 0)
+ {
+ if (rule->flags & MATCH_SENDER)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key %s specified twice in match rule\n", key);
+ goto failed;
+ }
+
+ if (!_dbus_validate_bus_name (&tmp_str, 0, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Sender name '%s' is invalid\n", value);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_sender (rule, value))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (strcmp (key, "interface") == 0)
+ {
+ if (rule->flags & MATCH_INTERFACE)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key %s specified twice in match rule\n", key);
+ goto failed;
+ }
+
+ if (!_dbus_validate_interface (&tmp_str, 0, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Interface name '%s' is invalid\n", value);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_interface (rule, value))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (strcmp (key, "member") == 0)
+ {
+ if (rule->flags & MATCH_MEMBER)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key %s specified twice in match rule\n", key);
+ goto failed;
+ }
+
+ if (!_dbus_validate_member (&tmp_str, 0, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Member name '%s' is invalid\n", value);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_member (rule, value))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (strcmp (key, "path") == 0 ||
+ strcmp (key, "path_namespace") == 0)
+ {
+ dbus_bool_t is_namespace = (strcmp (key, "path_namespace") == 0);
+
+ if (rule->flags & (MATCH_PATH | MATCH_PATH_NAMESPACE))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "path or path_namespace specified twice in match rule\n");
+ goto failed;
+ }
+
+ if (!_dbus_validate_path (&tmp_str, 0, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Path '%s' is invalid\n", value);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_path (rule, value, is_namespace))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (strcmp (key, "destination") == 0)
+ {
+ if (rule->flags & MATCH_DESTINATION)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Key %s specified twice in match rule\n", key);
+ goto failed;
+ }
+
+ if (!_dbus_validate_bus_name (&tmp_str, 0, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Destination name '%s' is invalid\n", value);
+ goto failed;
+ }
+
+ if (!bus_match_rule_set_destination (rule, value))
+ {
+ SET_OOM (error);
+ goto failed;
+ }
+ }
+ else if (strcmp (key, "eavesdrop") == 0)
+ {
+ /* do not detect "eavesdrop" being used more than once in rule:
+ * 1) it's not possible, it's only in the flags
+ * 2) it might be used twice to disable eavesdropping when it's
+ * automatically added (eg dbus-monitor/bustle) */
+
+ /* we accept only "true|false" as possible values */
+ if ((strcmp (value, "true") == 0))
+ {
+ bus_match_rule_set_client_is_eavesdropping (rule, TRUE);
+ }
+ else if (strcmp (value, "false") == 0)
+ {
+ bus_match_rule_set_client_is_eavesdropping (rule, FALSE);
+ }
+ else
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "eavesdrop='%s' is invalid, "
+ "it should be 'true' or 'false'\n",
+ value);
+ goto failed;
+ }
+ }
+ else if (strncmp (key, "arg", 3) == 0)
+ {
+ if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error))
+ goto failed;
+ }
+ else
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
+ "Unknown key \"%s\" in match rule",
+ key);
+ goto failed;
+ }
+
+ ++i;
+ }
+
+
+ goto out;
+
+ failed:
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ if (rule)
+ {
+ match_rule_unref (rule);
+ rule = NULL;
+ }
+
+ out:
+
+ i = 0;
+ while (tokens[i].key || tokens[i].value)
+ {
+ _dbus_assert (i < MAX_RULE_TOKENS);
+ dbus_free (tokens[i].key);
+ dbus_free (tokens[i].value);
+ ++i;
+ }
+
+ return rule;
+}
+
+typedef struct RulePool RulePool;
+struct RulePool
+{
+ /* Maps non-NULL interface names to non-NULL (DBusList **)s */
+ DBusHashTable *rules_by_iface;
+
+ /* List of MatchRules which don't specify an interface */
+ DBusList *rules_without_iface;
+};
+
+struct Matchmaker
+{
+ int refcount;
+
+ /* Pools of rules, grouped by the type of message they match. 0
+ * (DBUS_MESSAGE_TYPE_INVALID) represents rules that do not specify a message
+ * type.
+ */
+ RulePool rules_by_type[DBUS_NUM_MESSAGE_TYPES];
+
+ int last_cookie;
+};
+
+static void
+rule_list_free (DBusList **rules)
+{
+ while (*rules != NULL)
+ {
+ MatchRule *rule;
+
+ rule = (*rules)->data;
+ match_rule_unref (rule);
+ _dbus_list_remove_link (rules, *rules);
+ }
+}
+
+static void
+rule_list_ptr_free (DBusList **list)
+{
+ /* We have to cope with NULL because the hash table frees the "existing"
+ * value (which is NULL) when creating a new table entry...
+ */
+ if (list != NULL)
+ {
+ rule_list_free (list);
+ dbus_free (list);
+ }
+}
+
+Matchmaker*
+matchmaker_new (void)
+{
+ Matchmaker *matchmaker;
+ int i;
+
+ matchmaker = dbus_new0 (Matchmaker, 1);
+ if (matchmaker == NULL)
+ return NULL;
+
+ matchmaker->refcount = 1;
+ matchmaker->last_cookie = 0;
+
+ for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
+ {
+ RulePool *p = matchmaker->rules_by_type + i;
+
+ p->rules_by_iface = _dbus_hash_table_new (DBUS_HASH_STRING,
+ dbus_free, (DBusFreeFunction) rule_list_ptr_free);
+
+ if (p->rules_by_iface == NULL)
+ goto nomem;
+ }
+
+ return matchmaker;
+
+ nomem:
+ for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
+ {
+ RulePool *p = matchmaker->rules_by_type + i;
+
+ if (p->rules_by_iface == NULL)
+ break;
+ else
+ _dbus_hash_table_unref (p->rules_by_iface);
+ }
+ dbus_free (matchmaker);
+
+ return NULL;
+}
+
+DBusList **
+matchmaker_get_rules (Matchmaker *matchmaker,
+ int message_type,
+ const char *interface,
+ dbus_bool_t create)
+{
+ RulePool *p;
+
+ _dbus_assert (message_type >= 0);
+ _dbus_assert (message_type < DBUS_NUM_MESSAGE_TYPES);
+
+ _dbus_verbose ("Looking up rules for message_type %d, interface %s\n",
+ message_type,
+ interface != NULL ? interface : "<null>");
+
+ p = matchmaker->rules_by_type + message_type;
+
+ if (interface == NULL)
+ {
+ return &p->rules_without_iface;
+ }
+ else
+ {
+ DBusList **list;
+
+ list = _dbus_hash_table_lookup_string (p->rules_by_iface, interface);
+
+ if (list == NULL && create)
+ {
+ char *dupped_interface;
+
+ list = dbus_new0 (DBusList *, 1);
+ if (list == NULL)
+ return NULL;
+
+ dupped_interface = _dbus_strdup (interface);
+ if (dupped_interface == NULL)
+ {
+ dbus_free (list);
+ return NULL;
+ }
+
+ _dbus_verbose ("Adding list for type %d, iface %s\n", message_type,
+ interface);
+
+ if (!_dbus_hash_table_insert_string (p->rules_by_iface,
+ dupped_interface, list))
+ {
+ dbus_free (list);
+ dbus_free (dupped_interface);
+ return NULL;
+ }
+ }
+
+ return list;
+ }
+}
+
+static void
+bus_matchmaker_gc_rules (Matchmaker *matchmaker,
+ int message_type,
+ const char *interface,
+ DBusList **rules)
+{
+ RulePool *p;
+
+ if (interface == NULL)
+ return;
+
+ if (*rules != NULL)
+ return;
+
+ _dbus_verbose ("GCing HT entry for message_type %u, interface %s\n",
+ message_type, interface);
+
+ p = matchmaker->rules_by_type + message_type;
+
+ _dbus_assert (_dbus_hash_table_lookup_string (p->rules_by_iface, interface)
+ == rules);
+
+ _dbus_hash_table_remove_string (p->rules_by_iface, interface);
+}
+
+/* The rule can't be modified after it's added. */
+dbus_bool_t
+matchmaker_add_rule (Matchmaker *matchmaker,
+ MatchRule *rule)
+{
+ DBusList **rules;
+
+ _dbus_verbose ("Adding rule with message_type %d, interface %s\n",
+ rule->message_type,
+ rule->interface != NULL ? rule->interface : "<null>");
+
+ rules = matchmaker_get_rules (matchmaker, rule->message_type,
+ rule->interface, TRUE);
+
+ if (rules == NULL)
+ return FALSE;
+
+ if (!_dbus_list_append (rules, rule))
+ return FALSE;
+
+ rule->kdbus_cookie = ++(matchmaker->last_cookie);
+
+ bus_match_rule_ref (rule);
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ {
+ char *s = match_rule_to_string (rule);
+
+ _dbus_verbose ("Added match rule %s to connection %p\n",
+ s, rule->matches_go_to);
+ dbus_free (s);
+ }
+#endif
+
+ return TRUE;
+}
+
+DBusList* matchmaker_get_rules_list (Matchmaker *matchmaker,
+ MatchRule *rule)
+{
+ DBusList** list;
+
+ list = matchmaker_get_rules (matchmaker, rule->message_type,
+ rule->interface, FALSE);
+
+ if(list)
+ return *list;
+
+ return NULL;
+}
+
+dbus_bool_t
+match_rule_equal_lib (MatchRule *a,
+ MatchRule *b)
+{
+ if (a->flags != b->flags)
+ return FALSE;
+
+ if (a->matches_go_to != b->matches_go_to)
+ return FALSE;
+
+ if ((a->flags &MATCH_MESSAGE_TYPE) &&
+ a->message_type != b->message_type)
+ return FALSE;
+
+ if ((a->flags &MATCH_MEMBER) &&
+ strcmp (a->member, b->member) != 0)
+ return FALSE;
+
+ if ((a->flags &MATCH_PATH) &&
+ strcmp (a->path, b->path) != 0)
+ return FALSE;
+
+ if ((a->flags &MATCH_INTERFACE) &&
+ strcmp (a->interface, b->interface) != 0)
+ return FALSE;
+
+ if ((a->flags &MATCH_SENDER) &&
+ strcmp (a->sender, b->sender) != 0)
+ return FALSE;
+
+ if ((a->flags &MATCH_DESTINATION) &&
+ strcmp (a->destination, b->destination) != 0)
+ return FALSE;
+
+ /* we already compared the value of flags, and
+ *MATCH_CLIENT_IS_EAVESDROPPING does not have another struct member */
+
+ if (a->flags &MATCH_ARGS)
+ {
+ int i;
+
+ if (a->args_len != b->args_len)
+ return FALSE;
+
+ i = 0;
+ while (i < a->args_len)
+ {
+ int length;
+
+ if ((a->args[i] != NULL) != (b->args[i] != NULL))
+ return FALSE;
+
+ if (a->arg_lens[i] != b->arg_lens[i])
+ return FALSE;
+
+ length = a->arg_lens[i] & ~MATCH_ARG_FLAGS;
+
+ if (a->args[i] != NULL)
+ {
+ _dbus_assert (b->args[i] != NULL);
+ if (memcmp (a->args[i], b->args[i], length) != 0)
+ return FALSE;
+ }
+
+ ++i;
+ }
+ }
+
+ return TRUE;
+}
+
+static void
+bus_matchmaker_remove_rule_link (DBusList **rules,
+ DBusList *link)
+{
+ MatchRule *rule = link->data;
+
+ _dbus_list_remove_link (rules, link);
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ {
+ char *s = match_rule_to_string (rule);
+
+ _dbus_verbose ("Removed match rule %s for connection %p\n",
+ s, rule->matches_go_to);
+ dbus_free (s);
+ }
+#endif
+
+ match_rule_unref (rule);
+}
+
+/* Remove a single rule which is equal to the given rule by value */
+dbus_bool_t
+matchmaker_remove_rule_by_value (Matchmaker *matchmaker,
+ MatchRule *value,
+ DBusError *error)
+{
+ DBusList **rules;
+ DBusList *link = NULL;
+
+ _dbus_verbose ("Removing rule by value with message_type %d, interface %s\n",
+ value->message_type,
+ value->interface != NULL ? value->interface : "<null>");
+
+ rules = matchmaker_get_rules (matchmaker, value->message_type,
+ value->interface, FALSE);
+
+ if (rules != NULL)
+ {
+ /* we traverse backward because bus_connection_remove_match_rule()
+ * removes the most-recently-added rule
+ */
+ link = _dbus_list_get_last_link (rules);
+ while (link != NULL)
+ {
+ MatchRule *rule;
+ DBusList *prev;
+
+ rule = link->data;
+ prev = _dbus_list_get_prev_link (rules, link);
+
+ if (match_rule_equal_lib (rule, value))
+ {
+ bus_matchmaker_remove_rule_link (rules, link);
+ break;
+ }
+
+ link = prev;
+ }
+ }
+
+ if (link == NULL)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_NOT_FOUND,
+ "The given match rule wasn't found and can't be removed");
+ return FALSE;
+ }
+
+ bus_matchmaker_gc_rules (matchmaker, value->message_type, value->interface,
+ rules);
+
+ return TRUE;
+}
+
+static void
+rule_list_remove (DBusList **rules)
+{
+ DBusList *link;
+
+ link = _dbus_list_get_first_link (rules);
+ while (link != NULL)
+ {
+ DBusList *next;
+
+ next = _dbus_list_get_next_link (rules, link);
+ bus_matchmaker_remove_rule_link (rules, link);
+ link = next;
+ }
+}
+
+void
+free_matchmaker (Matchmaker *matchmaker)
+{
+ int i;
+
+ _dbus_verbose ("Removing all rules for connection\n");
+
+ for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
+ {
+ RulePool *p = matchmaker->rules_by_type + i;
+ DBusHashIter iter;
+
+ rule_list_remove (&p->rules_without_iface);
+
+ _dbus_hash_iter_init (p->rules_by_iface, &iter);
+ while (_dbus_hash_iter_next (&iter))
+ {
+ DBusList **items = _dbus_hash_iter_get_value (&iter);
+
+ rule_list_remove (items);
+
+ if (*items == NULL)
+ _dbus_hash_iter_remove_entry (&iter);
+ }
+ }
+}
+
+static dbus_bool_t
+name_matches_name_rule (DBusTransport *transport,
+ const char *name,
+ const char *rule)
+{
+ if( !strncmp(rule, ":1.", 3) == !strncmp(name, ":1.", 3) )
+ {
+ if(!strcmp(name, rule))
+ return TRUE;
+ }
+ else
+ {
+ struct nameInfo info;
+
+ if(0 == kdbus_NameQuery(rule, transport, &info))
+ {
+ __u64 sender_id;
+
+ _dbus_verbose("Owner discovered: :1.%llu\n", (unsigned long long int)info.uniqueId);
+ free(info.sec_label);
+ sender_id = strtoull(&name[3], NULL, 10);
+ if(sender_id && (sender_id < ULLONG_MAX) && (sender_id == info.uniqueId))
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+static dbus_bool_t
+str_has_prefix (const char *str, const char *prefix)
+{
+ size_t prefix_len;
+ prefix_len = strlen (prefix);
+ if (strncmp (str, prefix, prefix_len) == 0)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+dbus_bool_t
+match_rule_matches (DBusTransport *transport,
+ MatchRule *rule,
+ DBusMessage *message,
+ MatchFlags already_matched)
+{
+ dbus_bool_t wants_to_eavesdrop = FALSE;
+ int flags;
+
+ /* All features of the match rule are AND'd together,
+ * so FALSE if any of them don't match.
+ */
+
+ /* Don't bother re-matching features we've already checked implicitly. */
+ flags = rule->flags & (~already_matched);
+
+ if (flags & MATCH_CLIENT_IS_EAVESDROPPING)
+ wants_to_eavesdrop = TRUE;
+
+ if (flags & MATCH_MESSAGE_TYPE)
+ {
+ _dbus_assert (rule->message_type != DBUS_MESSAGE_TYPE_INVALID);
+
+ if (rule->message_type != dbus_message_get_type (message))
+ return FALSE;
+ }
+
+ if (flags & MATCH_INTERFACE)
+ {
+ const char *iface;
+
+ _dbus_assert (rule->interface != NULL);
+
+ iface = dbus_message_get_interface (message);
+ if (iface == NULL)
+ return FALSE;
+
+ if (strcmp (iface, rule->interface) != 0)
+ return FALSE;
+ }
+
+ if (flags & MATCH_MEMBER)
+ {
+ const char *member;
+
+ _dbus_assert (rule->member != NULL);
+
+ member = dbus_message_get_member (message);
+ if (member == NULL)
+ return FALSE;
+
+ if (strcmp (member, rule->member) != 0)
+ return FALSE;
+ }
+
+ if (flags & MATCH_SENDER)
+ {
+ _dbus_assert (rule->sender != NULL);
+
+ if (!name_matches_name_rule (transport, dbus_message_get_sender(message), rule->sender))
+ return FALSE;
+ }
+
+ /* Note: this part is relevant for eavesdropper rules:
+ * Two cases:
+ * 1) rule has a destination to be matched
+ * (flagMATCH_DESTINATION present). Rule will match if:
+ * - rule->destination matches the addressed_recipient
+ * AND
+ * - wants_to_eavesdrop=TRUE
+ *
+ * Note: (the case in which addressed_recipient is the actual rule owner
+ * is handled elsewere in dispatch.c:bus_dispatch_matches().
+ *
+ * 2) rule has no destination. Rule will match if:
+ * - message has no specified destination (ie broadcasts)
+ * (Note: this will rule out unicast method calls and unicast signals,
+ * fixing FDO#269748)
+ * OR
+ * - wants_to_eavesdrop=TRUE (destination-catch-all situation)
+ */
+ if (flags & MATCH_DESTINATION)
+ {
+ const char *destination;
+
+ _dbus_assert (rule->destination != NULL);
+
+ destination = dbus_message_get_destination (message);
+ if (destination == NULL)
+ /* broadcast, but this rule specified a destination: no match */
+ return FALSE;
+
+ /* rule owner does not intend to eavesdrop: we'll deliver only msgs
+ * directed to it, NOT MATCHING */
+ if (!wants_to_eavesdrop)
+ return FALSE;
+
+ if (!name_matches_name_rule (transport, destination, rule->destination))
+ return FALSE;
+
+ }
+ else /* no destination in rule */
+ {
+ dbus_bool_t msg_is_broadcast;
+
+ _dbus_assert (rule->destination == NULL);
+
+ msg_is_broadcast = (dbus_message_get_destination (message) == NULL);
+
+ if (!wants_to_eavesdrop && !msg_is_broadcast)
+ return FALSE;
+
+ /* if we are here rule owner intends to eavesdrop
+ * OR
+ * message is being broadcasted */
+ }
+
+ if (flags & MATCH_PATH)
+ {
+ const char *path;
+
+ _dbus_assert (rule->path != NULL);
+
+ path = dbus_message_get_path (message);
+ if (path == NULL)
+ return FALSE;
+
+ if (strcmp (path, rule->path) != 0)
+ return FALSE;
+ }
+
+ if (flags & MATCH_PATH_NAMESPACE)
+ {
+ const char *path;
+ int len;
+
+ _dbus_assert (rule->path != NULL);
+
+ path = dbus_message_get_path (message);
+ if (path == NULL)
+ return FALSE;
+
+ if (!str_has_prefix (path, rule->path))
+ return FALSE;
+
+ len = strlen (rule->path);
+
+ /* Check that the actual argument is within the expected
+ * namespace, rather than just starting with that string,
+ * by checking that the matched prefix is followed by a '/'
+ * or the end of the path.
+ */
+ if (path[len] != '\0' && path[len] != '/')
+ return FALSE;
+ }
+
+ if (flags & MATCH_ARGS)
+ {
+ int i;
+ DBusMessageIter iter;
+
+ _dbus_assert (rule->args != NULL);
+
+ dbus_message_iter_init (message, &iter);
+
+ i = 0;
+ while (i < rule->args_len)
+ {
+ int current_type;
+ const char *expected_arg;
+ int expected_length;
+ dbus_bool_t is_path, is_namespace;
+
+ expected_arg = rule->args[i];
+ expected_length = rule->arg_lens[i] & ~MATCH_ARG_FLAGS;
+ is_path = (rule->arg_lens[i] & MATCH_ARG_IS_PATH) != 0;
+ is_namespace = (rule->arg_lens[i] & MATCH_ARG_NAMESPACE) != 0;
+
+ current_type = dbus_message_iter_get_arg_type (&iter);
+
+ if (expected_arg != NULL)
+ {
+ const char *actual_arg;
+ int actual_length;
+
+ if (current_type != DBUS_TYPE_STRING &&
+ (!is_path || current_type != DBUS_TYPE_OBJECT_PATH))
+ return FALSE;
+
+ actual_arg = NULL;
+ dbus_message_iter_get_basic (&iter, &actual_arg);
+ _dbus_assert (actual_arg != NULL);
+
+ actual_length = strlen (actual_arg);
+
+ if (is_path)
+ {
+ if (actual_length < expected_length &&
+ actual_arg[actual_length - 1] != '/')
+ return FALSE;
+
+ if (expected_length < actual_length &&
+ expected_arg[expected_length - 1] != '/')
+ return FALSE;
+
+ if (memcmp (actual_arg, expected_arg,
+ MIN (actual_length, expected_length)) != 0)
+ return FALSE;
+ }
+ else if (is_namespace)
+ {
+ if (expected_length > actual_length)
+ return FALSE;
+
+ /* If the actual argument doesn't start with the expected
+ * namespace, then we don't match.
+ */
+ if (memcmp (expected_arg, actual_arg, expected_length) != 0)
+ return FALSE;
+
+ if (expected_length < actual_length)
+ {
+ /* Check that the actual argument is within the expected
+ * namespace, rather than just starting with that string,
+ * by checking that the matched prefix ends in a '.'.
+ *
+ * This doesn't stop "foo.bar." matching "foo.bar..baz"
+ * which is an invalid namespace, but at some point the
+ * daemon can't cover up for broken services.
+ */
+ if (actual_arg[expected_length] != '.')
+ return FALSE;
+ }
+ /* otherwise we had an exact match. */
+ }
+ else
+ {
+ if (expected_length != actual_length ||
+ memcmp (expected_arg, actual_arg, expected_length) != 0)
+ return FALSE;
+ }
+
+ }
+
+ if (current_type != DBUS_TYPE_INVALID)
+ dbus_message_iter_next (&iter);
+
+ ++i;
+ }
+ }
+
+ return TRUE;
+}
+
+int
+_match_rule_get_message_type (MatchRule *rule)
+{
+ if (rule->flags & MATCH_MESSAGE_TYPE)
+ return rule->message_type;
+ else
+ return DBUS_MESSAGE_TYPE_INVALID;
+}
+
+const char *
+_match_rule_get_interface (MatchRule *rule)
+{
+ if (rule->flags & MATCH_INTERFACE)
+ return rule->interface;
+ else
+ return NULL;
+}
+
+const char *
+_match_rule_get_member (MatchRule *rule)
+{
+ if (rule->flags & MATCH_MEMBER)
+ return rule->member;
+ else
+ return NULL;
+}
+
+const char *
+_match_rule_get_sender (MatchRule *rule)
+{
+ if (rule->flags & MATCH_SENDER)
+ return rule->sender;
+ else
+ return NULL;
+}
+
+const char *
+_match_rule_get_destination (MatchRule *rule)
+{
+ if (rule->flags & MATCH_DESTINATION)
+ return rule->destination;
+ else
+ return NULL;
+}
+
+const char *
+_match_rule_get_path (MatchRule *rule)
+{
+ if (rule->flags & MATCH_PATH)
+ return rule->path;
+ else
+ return NULL;
+}
+
+const char *
+_match_rule_get_path_namespace (MatchRule *rule)
+{
+ if (rule->flags & MATCH_PATH_NAMESPACE)
+ return rule->path;
+ else
+ return NULL;
+}
+
+int
+_match_rule_get_args_len (MatchRule *rule)
+{
+ return rule->args_len;
+}
+
+const char *
+_match_rule_get_args (MatchRule *rule, int i)
+{
+ return rule->args[i];
+}
+
+unsigned int
+_match_rule_get_arg_lens (MatchRule *rule, int i)
+{
+ return rule->arg_lens[i];
+}
--- /dev/null
+/*
+ * dbus-signals.h
+ *
+ * Created on: Feb 26, 2014
+ * Author: r.pajak
+ */
+
+#ifndef DBUS_SIGNALS_H_
+#define DBUS_SIGNALS_H_
+
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* signals.h Bus signal connection implementation
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-string.h>
+#include <dbus/dbus-sysdeps.h>
+#include <dbus/dbus-transport.h>
+
+typedef struct Matchmaker Matchmaker;
+typedef struct MatchRule MatchRule;
+
+#ifndef MATCH_ARG_NAMESPACE
+#define MATCH_ARG_NAMESPACE 0x4000000u
+#endif
+#ifndef MATCH_ARG_IS_PATH
+#define MATCH_ARG_IS_PATH 0x8000000u
+#endif
+
+typedef enum
+{
+ MATCH_MESSAGE_TYPE = 1 << 0,
+ MATCH_INTERFACE = 1 << 1,
+ MATCH_MEMBER = 1 << 2,
+ MATCH_SENDER = 1 << 3,
+ MATCH_DESTINATION = 1 << 4,
+ MATCH_PATH = 1 << 5,
+ MATCH_ARGS = 1 << 6,
+ MATCH_PATH_NAMESPACE = 1 << 7,
+ MATCH_CLIENT_IS_EAVESDROPPING = 1 << 8
+} MatchFlags;
+
+void match_rule_unref (MatchRule *rule);
+void match_rule_set_cookie (MatchRule *rule, dbus_uint64_t cookie);
+dbus_uint64_t match_rule_get_cookie (MatchRule *rule);
+
+/* Calling this methods a client declares that it is creating a rule which
+ * needs to eavesdrop (e.g., dbus-monitor), any other created rules not
+ * setting themselves as eavesdropping won't receive any message not addressed
+ * to them, when eavedrop is enabled in the policy. On the other hand, when
+ * eavedrop is not enabled in policy, this method won't have any effect */
+//void bus_match_rule_set_client_is_eavesdropping (BusMatchRule *rule,
+// dbus_bool_t is_eavesdropping);
+
+DBusList ** matchmaker_get_rules (Matchmaker *matchmaker,
+ int message_type,
+ const char *interface,
+ dbus_bool_t create);
+
+MatchRule* match_rule_parse (DBusConnection *matches_go_to,
+ const DBusString *rule_text,
+ DBusError *error);
+
+dbus_bool_t match_rule_equal_lib (MatchRule *a, MatchRule *b);
+
+
+Matchmaker* matchmaker_new (void);
+
+dbus_bool_t matchmaker_add_rule (Matchmaker *matchmaker,
+ MatchRule *rule);
+DBusList* matchmaker_get_rules_list (Matchmaker *matchmaker,
+ MatchRule *rule);
+dbus_bool_t matchmaker_remove_rule_by_value (Matchmaker *matchmaker,
+ MatchRule *value,
+ DBusError *error);
+void free_matchmaker (Matchmaker *matchmaker);
+
+dbus_bool_t match_rule_matches (DBusTransport *transport,
+ MatchRule *rule,
+ DBusMessage *message,
+ MatchFlags already_matched);
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+char* match_rule_to_string (MatchRule *rule);
+#endif
+
+int _match_rule_get_message_type (MatchRule *rule);
+const char * _match_rule_get_interface (MatchRule *rule);
+const char * _match_rule_get_member (MatchRule *rule);
+const char * _match_rule_get_sender (MatchRule *rule);
+const char * _match_rule_get_destination (MatchRule *rule);
+const char * _match_rule_get_path (MatchRule *rule);
+const char * _match_rule_get_path_namespace (MatchRule *rule);
+int _match_rule_get_args_len (MatchRule *rule);
+const char * _match_rule_get_args (MatchRule *rule, int i);
+unsigned int _match_rule_get_arg_lens (MatchRule *rule, int i);
+
+#endif /* DBUS_SIGNALS_H_ */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-transport-kdbus.c kdbus subclasses of DBusTransport
+ *
+ * Copyright (C) 2002, 2003, 2004, 2006 Red Hat Inc
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version and under the terms of the GNU
+ * Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#include "../config.h"
+#include "dbus-transport.h"
+#include "dbus-transport-kdbus.h"
+#include "dbus-transport-protected.h"
+#include "dbus-connection-internal.h"
+#include "dbus-marshal-gvariant.h"
+#include "dbus-asv-util.h"
+#include "kdbus.h"
+#include "dbus-watch.h"
+#include "dbus-errors.h"
+#include "dbus-bus.h"
+#include "kdbus-common.h"
+#include <linux/types.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <linux/memfd.h>
+#include <fcntl.h>
+
+int debug = -1;
+
+/* FIXME shouldn't it be in fcntl.h header file? copied from systemd's missing.h */
+#ifndef F_LINUX_SPECIFIC_BASE
+#define F_LINUX_SPECIFIC_BASE 1024
+#endif
+
+#ifndef F_ADD_SEALS
+#define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9)
+#define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10)
+
+#define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */
+#define F_SEAL_SHRINK 0x0002 /* prevent file from shrinking */
+#define F_SEAL_GROW 0x0004 /* prevent file from growing */
+#define F_SEAL_WRITE 0x0008 /* prevent writes */
+#endif
+
+/* ALIGN8 and KDBUS_FOREACH taken from systemd */
+#define ALIGN8(l) (((l) + 7) & ~7)
+#define KDBUS_FOREACH(iter, first, _size) \
+ for (iter = (first); \
+ ((uint8_t *)(iter) < (uint8_t *)(first) + (_size)) && \
+ ((uint8_t *)(iter) >= (uint8_t *)(first)); \
+ iter = (void*)(((uint8_t *)iter) + ALIGN8((iter)->size)))
+#define KDBUS_DEFAULT_TIMEOUT_NS 5000000000LU
+
+/**
+ * @defgroup DBusTransportKdbus DBusTransport implementations for kdbus
+ * @ingroup DBusInternals
+ * @brief Implementation details of DBusTransport on kdbus
+ *
+ * @{
+ */
+
+/** Default Size of the memory area for received non-memfd messages. */
+#define RECEIVE_POOL_SIZE_DEFAULT_SIZE (2 * 1024LU * 1024LU)
+/** Name of environmental variable to define receive pool size*/
+#define RECEIVE_POOL_SIZE_ENV_VAR_NAME "KDBUS_MEMORY_POOL_SIZE"
+/** Max size of pool size in megabytes*/
+#define RECEIVE_POOL_SIZE_MAX_MBYTES 64
+/** Min size of pool size in kilobytes*/
+#define RECEIVE_POOL_SIZE_MIN_KBYTES 16
+
+/** Over this memfd is used to send (if it is not broadcast). */
+#define MEMFD_SIZE_THRESHOLD (512 * 1024LU)
+
+/** Define max bytes read or written in one iteration.
+* This is to avoid blocking on reading or writing for too long. It is checked after each message is sent or received,
+* so if message is bigger than MAX_BYTES_PER_ITERATION it will be handled in one iteration, but sending/writing
+* will break after that message.
+**/
+#define MAX_BYTES_PER_ITERATION 16384
+
+#if (MEMFD_SIZE_THRESHOLD > KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE)
+ #error Memfd size threshold higher than max kdbus message payload vector size
+#endif
+
+/** Enables verbosing more information about kdbus message.
+ * Works only if DBUS_VERBOSE=1 is used.
+ */
+#define KDBUS_MSG_DECODE_DEBUG 0
+
+#define MSG_ITEM_BUILD_VEC(data, datasize) \
+ item->type = KDBUS_ITEM_PAYLOAD_VEC; \
+ item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); \
+ item->vec.address = (unsigned long) data; \
+ item->vec.size = datasize;
+
+/**
+ * Opaque object representing a transport.
+ */
+typedef struct DBusTransportKdbus DBusTransportKdbus;
+
+/**
+ * Implementation details of DBusTransportKdbus. All members are private.
+ */
+struct DBusTransportKdbus
+{
+ DBusTransport base; /**< Parent instance */
+ int fd; /**< File descriptor. */
+ DBusWatch *read_watch; /**< Watch for readability. */
+ DBusWatch *write_watch; /**< Watch for writability. */
+
+ int max_bytes_read_per_iteration; /**< To avoid blocking too long. */
+ int max_bytes_written_per_iteration; /**< To avoid blocking too long. */
+
+ void* kdbus_mmap_ptr; /**< Mapped memory where kdbus (kernel) writes
+ * messages incoming to us.
+ */
+ uint32_t receive_pool_size; /**< Size of mapped memory buffer pointed by kdbus_mmap_ptr*/
+ struct kdbus_bloom_parameter bloom; /**< bloom parameters*/
+ char* my_DBus_unique_name; /**< unique name in DBus string format - :1.x , where x is kdbus id*/
+ __u64 my_kdbus_id; /**< unique id given by kdbus bus*/
+ char* activator; /**< well known name for activator */
+ Matchmaker *matchmaker; /**< for match rules management */
+ char *daemon_unique_name; /**< unique name of the dbus-daemon (org.freedesktop.DBus owner)*/
+ dbus_uint32_t client_serial; /**< serial number for messages synthesized by library*/
+ char bus_id[sizeof(((struct kdbus_cmd_hello *)(0))->id128)];
+};
+
+/**
+ * Gets size in bytes of bloom filter field.
+ * This size is got from the bus during connection procedure.
+ * @param transport transport
+ * @returns size of bloom
+ */
+__u64
+dbus_transport_get_bloom_size(DBusTransport *transport)
+{
+ return ((DBusTransportKdbus*)transport)->bloom.size;
+}
+
+/**
+ * Gets hash count of bloom filter field.
+ *
+ * @param transport transport
+ * @returns hash_n
+ */
+__u64
+dbus_transport_get_bloom_n_hash(DBusTransport *transport)
+{
+ return ((DBusTransportKdbus*)transport)->bloom.n_hash;
+}
+
+/**
+ * Gets pointer to the memory pool, wher received messages are
+ * placed and some ioctls return their info
+ * @param transport transport
+ * @returns pointer to the pool
+ */
+void*
+dbus_transport_get_pool_pointer(DBusTransport *transport)
+{
+ return ((DBusTransportKdbus*)transport)->kdbus_mmap_ptr;
+}
+
+/**
+ * Creates unique name string frong unique id.
+ *
+ * @param id unique id
+ * @returns allocated string with unique name
+ *
+ * Caller has to free allocated string with free.
+ */
+static char *
+create_unique_name_from_unique_id (unsigned long long id)
+{
+ char *str = NULL;
+ if (asprintf (&str, ":1.%llu", id) == -1)
+ str = NULL;
+ return str;
+}
+
+/**
+ * Puts locally generated message into received messages queue
+ * @param message message that will be added
+ * @param connection connection to which message will be added
+ * @returns TRUE on success, FALSE on memory allocation error
+ */
+static dbus_bool_t
+add_message_to_received(DBusMessage *message,
+ DBusConnection *connection)
+{
+ DBusList *message_link;
+
+ message_link = _dbus_list_alloc_link (message);
+ if (message_link == NULL)
+ {
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ dbus_message_lock (message);
+
+ _dbus_connection_queue_synthesized_message_link(connection, message_link);
+ return TRUE;
+}
+
+static int
+reply_with_error_preset_sender(const char *error_type,
+ const char *template,
+ const char *object,
+ DBusMessage *message,
+ DBusConnection *connection,
+ const char *sender)
+{
+ DBusMessage *errMessage;
+ char* error_msg = "";
+
+ if(template)
+ {
+ error_msg = alloca(strlen(template) + strlen(object) + 1);
+ sprintf(error_msg, template, object);
+ }
+ else if(object)
+ error_msg = (char*)object;
+
+ errMessage = _dbus_generate_local_error_message( dbus_message_get_serial(message),
+ (char*)error_type,
+ error_msg);
+
+ if(errMessage == NULL)
+ return -1;
+
+ if (sender)
+ dbus_message_set_sender(errMessage, sender);
+
+ if (add_message_to_received(errMessage, connection))
+ return 0;
+
+ return -1;
+}
+
+/**
+ * Generates local error message as a reply to message given as parameter
+ * and adds generated error message to received messages queue.
+ * @param error_type type of error, preferably DBUS_ERROR_(...)
+ * @param template Template of error description. It can has formatting
+ * characters to print object string into it. Can be NULL.
+ * @param object String to print into error description. Can be NULL.
+ * If object is not NULL while template is NULL, the object string
+ * will be the only error description.
+ * @param message Message for which the error reply is generated.
+ * @param connection The connection.
+ * @returns 0 on success, otherwise -1
+ */
+static int
+reply_with_error(const char *error_type,
+ const char *template,
+ const char *object,
+ DBusMessage *message,
+ DBusConnection *connection)
+{
+ return reply_with_error_preset_sender(error_type, template,
+ object, message, connection, NULL);
+}
+
+/**
+ * Generates reply to the message given as a parameter with one item in the reply body
+ * and adds generated reply message to received messages queue.
+ * @param message The message we are replying to.
+ * @param data_type Type of data sent in the reply.Use DBUS_TYPE_(...)
+ * @param pData Address of data sent in the reply.
+ * @param connection The connection
+ * @returns 0 on success, otherwise -1
+ */
+static int
+reply_1_data(DBusMessage *message,
+ int data_type,
+ void *pData,
+ DBusConnection *connection)
+{
+ DBusMessageIter args;
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(message);
+ if(reply == NULL)
+ return -1;
+
+ if (!dbus_message_set_sender(reply, DBUS_SERVICE_DBUS))
+ goto oom_free;
+
+ dbus_message_iter_init_append(reply, &args);
+ if (!dbus_message_iter_append_basic(&args, data_type, pData))
+ goto oom_free;
+
+ if (!add_message_to_received(reply, connection))
+ goto oom_free;
+
+ return 0;
+
+oom_free:
+ dbus_message_unref (reply);
+
+ return -1;
+}
+
+static int
+reply_ack(DBusMessage *message,
+ DBusConnection *connection)
+{
+ DBusMessage *reply;
+ int ret = -1;
+
+ reply = dbus_message_new_method_return(message);
+ if(reply != NULL)
+ {
+ if (add_message_to_received(reply, connection))
+ ret = 0;
+ else
+ dbus_message_unref (reply);
+ }
+ return ret;
+}
+
+static int
+reply_fixed_array (DBusMessage *message,
+ int element_type,
+ const void *data,
+ int n_elements,
+ DBusConnection *connection)
+{
+ DBusMessageIter args, array_iter;
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(message);
+ if(reply == NULL)
+ return -1;
+
+ if (!dbus_message_set_sender(reply, DBUS_SERVICE_DBUS))
+ goto oom_free;
+
+ dbus_message_iter_init_append(reply, &args);
+
+ if (!dbus_message_iter_open_container (&args,
+ DBUS_TYPE_ARRAY,
+ DBUS_TYPE_BYTE_AS_STRING,
+ &array_iter))
+ goto oom_free;
+
+ if (!dbus_message_iter_append_fixed_array(&array_iter, element_type, &data, n_elements))
+ goto oom_array_iter;
+
+ if (!dbus_message_iter_close_container (&args, &array_iter))
+ goto oom_free;
+
+ if(!add_message_to_received(reply, connection))
+ goto oom_free;
+
+ return 0;
+
+oom_array_iter:
+ dbus_message_iter_abandon_container (&args, &array_iter);
+
+oom_free:
+ dbus_message_unref (reply);
+ return -1;
+}
+
+/**
+ * Retrieves file descriptor to memory pool from kdbus module and stores
+ * it in kdbus_transport->memfd. It is then used to send large message.
+ * Triggered when message payload is over MEMFD_SIZE_THRESHOLD
+ * @param kdbus_transport DBusTransportKdbus transport structure
+ * @returns 0 on success, otherwise -1
+ */
+static int
+kdbus_acquire_memfd(DBusTransportKdbus *kdbus_transport,
+ uint64_t fsize)
+{
+ int fd;
+
+ /* FIXME add HAVE_MEMFD_CREATE */
+ if ((fd = syscall(__NR_memfd_create, "kdbus", MFD_ALLOW_SEALING | MFD_CLOEXEC )) < 0)
+ {
+ _dbus_verbose("memfd_create failed (%d): %m\n", fd);
+ }
+
+ _dbus_verbose("%s: memfd=%d\n", __FUNCTION__, fd);
+ return fd;
+}
+
+/**
+ * Allocates and initializes kdbus message structure.
+ * @param name Well-known name or NULL. If NULL, dst_id must be supplied.
+ * @param dst_id Numeric id of recipient. Ignored if name is not NULL.
+ * @param body_size Size of message body (May be 0).
+ * @param use_memfd Flag to build memfd message.
+ * @param fds_count Number of file descriptors sent in the message.
+ * @param transport transport
+ * @returns initialized kdbus message or NULL if malloc failed
+ */
+static struct
+kdbus_msg* kdbus_init_msg(const char *name,
+ __u64 dst_id,
+ uint64_t body_size,
+ dbus_bool_t use_memfd,
+ int fds_count,
+ DBusTransportKdbus *transport)
+{
+ struct kdbus_msg* msg;
+ uint64_t msg_size;
+
+ msg_size = sizeof(struct kdbus_msg);
+
+ if(use_memfd == TRUE) // bulk data - memfd
+ msg_size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_memfd));
+ else
+ {
+ msg_size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); //header is a must
+ while(body_size > KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE)
+ {
+ msg_size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec));
+ body_size -= KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE;
+ }
+ if((int64_t)body_size > 0)
+ msg_size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec));
+ }
+
+ if(fds_count)
+ msg_size += KDBUS_ITEM_SIZE(sizeof(int)*fds_count);
+
+ if (name)
+ msg_size += KDBUS_ITEM_SIZE(strlen(name) + 1);
+ else if (dst_id == KDBUS_DST_ID_BROADCAST)
+ msg_size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter) + transport->bloom.size);
+
+ msg = malloc(msg_size);
+ if (!msg)
+ {
+ _dbus_verbose("Error allocating memory for: %s,%s\n", _dbus_strerror (errno),
+ _dbus_error_from_errno (errno));
+ return NULL;
+ }
+
+ memset(msg, 0, msg_size);
+ msg->size = msg_size;
+ msg->payload_type = KDBUS_PAYLOAD_DBUS;
+ msg->dst_id = name ? 0 : dst_id;
+/* msg->src_id = transport->my_kdbus_id; */ /* not needed, overwritten by kernel anyway */
+
+ return msg;
+}
+
+/*
+ * Macros for SipHash algorithm
+ */
+#define ROTL(x,b) (uint64_t)( ((x) << (b)) | ( (x) >> (64 - (b))) )
+
+#define U32TO8_LE(p, v) \
+ (p)[0] = (unsigned char)((v) ); (p)[1] = (unsigned char)((v) >> 8); \
+ (p)[2] = (unsigned char)((v) >> 16); (p)[3] = (unsigned char)((v) >> 24);
+
+#define U64TO8_LE(p, v) \
+ U32TO8_LE((p), (uint32_t)((v) )); \
+ U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
+
+#define U8TO64_LE(p) \
+ (((uint64_t)((p)[0]) ) | \
+ ((uint64_t)((p)[1]) << 8) | \
+ ((uint64_t)((p)[2]) << 16) | \
+ ((uint64_t)((p)[3]) << 24) | \
+ ((uint64_t)((p)[4]) << 32) | \
+ ((uint64_t)((p)[5]) << 40) | \
+ ((uint64_t)((p)[6]) << 48) | \
+ ((uint64_t)((p)[7]) << 56))
+
+#define SIPROUND \
+ do { \
+ v0 += v1; v1=ROTL(v1,13); v1 ^= v0; v0=ROTL(v0,32); \
+ v2 += v3; v3=ROTL(v3,16); v3 ^= v2; \
+ v0 += v3; v3=ROTL(v3,21); v3 ^= v0; \
+ v2 += v1; v1=ROTL(v1,17); v1 ^= v2; v2=ROTL(v2,32); \
+ } while(0)
+
+
+/*
+ * Hash keys for bloom filters
+ */
+const unsigned char hash_keys[8][16] =
+{
+ {0xb9,0x66,0x0b,0xf0,0x46,0x70,0x47,0xc1,0x88,0x75,0xc4,0x9c,0x54,0xb9,0xbd,0x15},
+ {0xaa,0xa1,0x54,0xa2,0xe0,0x71,0x4b,0x39,0xbf,0xe1,0xdd,0x2e,0x9f,0xc5,0x4a,0x3b},
+ {0x63,0xfd,0xae,0xbe,0xcd,0x82,0x48,0x12,0xa1,0x6e,0x41,0x26,0xcb,0xfa,0xa0,0xc8},
+ {0x23,0xbe,0x45,0x29,0x32,0xd2,0x46,0x2d,0x82,0x03,0x52,0x28,0xfe,0x37,0x17,0xf5},
+ {0x56,0x3b,0xbf,0xee,0x5a,0x4f,0x43,0x39,0xaf,0xaa,0x94,0x08,0xdf,0xf0,0xfc,0x10},
+ {0x31,0x80,0xc8,0x73,0xc7,0xea,0x46,0xd3,0xaa,0x25,0x75,0x0f,0x9e,0x4c,0x09,0x29},
+ {0x7d,0xf7,0x18,0x4b,0x7b,0xa4,0x44,0xd5,0x85,0x3c,0x06,0xe0,0x65,0x53,0x96,0x6d},
+ {0xf2,0x77,0xe9,0x6f,0x93,0xb5,0x4e,0x71,0x9a,0x0c,0x34,0x88,0x39,0x25,0xbf,0x35}
+};
+
+/*
+ * SipHash algorithm
+ */
+static void
+_g_siphash24 (unsigned char out[8],
+ const void *_in,
+ size_t inlen,
+ const unsigned char k[16])
+{
+ uint64_t v0 = 0x736f6d6570736575ULL;
+ uint64_t v1 = 0x646f72616e646f6dULL;
+ uint64_t v2 = 0x6c7967656e657261ULL;
+ uint64_t v3 = 0x7465646279746573ULL;
+ uint64_t b;
+ uint64_t k0 = U8TO64_LE (k);
+ uint64_t k1 = U8TO64_LE (k + 8);
+ uint64_t m;
+ const unsigned char *in = _in;
+ const unsigned char *end = in + inlen - (inlen % sizeof(uint64_t));
+ const int left = inlen & 7;
+ b = ((uint64_t) inlen) << 56;
+ v3 ^= k1;
+ v2 ^= k0;
+ v1 ^= k1;
+ v0 ^= k0;
+
+ for (; in != end; in += 8)
+ {
+ m = U8TO64_LE (in);
+ v3 ^= m;
+ SIPROUND;
+ SIPROUND;
+ v0 ^= m;
+ }
+
+ switch (left)
+ {
+ case 7: b |= ((uint64_t) in[6]) << 48;
+ case 6: b |= ((uint64_t) in[5]) << 40;
+ case 5: b |= ((uint64_t) in[4]) << 32;
+ case 4: b |= ((uint64_t) in[3]) << 24;
+ case 3: b |= ((uint64_t) in[2]) << 16;
+ case 2: b |= ((uint64_t) in[1]) << 8;
+ case 1: b |= ((uint64_t) in[0]); break;
+ case 0: break;
+ }
+
+ v3 ^= b;
+ SIPROUND;
+ SIPROUND;
+ v0 ^= b;
+
+ v2 ^= 0xff;
+ SIPROUND;
+ SIPROUND;
+ SIPROUND;
+ SIPROUND;
+ b = v0 ^ v1 ^ v2 ^ v3;
+ U64TO8_LE (out, b);
+}
+
+static void
+bloom_add_data (uint64_t bloom_data [],
+ struct kdbus_bloom_parameter *bloom_params,
+ const void *data,
+ size_t n)
+{
+ unsigned char hash[8];
+ uint64_t bit_num;
+ unsigned int bytes_num = 0;
+ unsigned int cnt_1, cnt_2;
+ unsigned int hash_index = 0;
+
+ unsigned int c = 0;
+ uint64_t p = 0;
+
+ bit_num = bloom_params->size * 8;
+
+ if (bit_num > 1)
+ bytes_num = ((__builtin_clzll(bit_num) ^ 63U) + 7) / 8;
+
+ for (cnt_1 = 0; cnt_1 < bloom_params->n_hash; cnt_1++)
+ {
+ for (cnt_2 = 0, hash_index = 0; cnt_2 < bytes_num; cnt_2++)
+ {
+ if (c <= 0)
+ {
+ _g_siphash24(hash, data, n, hash_keys[hash_index++]);
+ c += 8;
+ }
+
+ p = (p << 8ULL) | (uint64_t) hash[8 - c];
+ c--;
+ }
+
+ p &= bit_num - 1;
+ bloom_data[p >> 6] |= 1ULL << (p & 63);
+ }
+}
+
+static void
+bloom_add_pair (uint64_t bloom_data [],
+ struct kdbus_bloom_parameter *bloom_params,
+ const char *parameter,
+ const char *value)
+{
+ char buf[1024];
+ size_t size;
+
+ size = strlen(parameter) + strlen(value) + 1;
+ if (size > 1024)
+ return;
+
+ strcpy(stpcpy(stpcpy(buf, parameter), ":"), value);
+ bloom_add_data (bloom_data, bloom_params, buf, size);
+}
+
+static void
+bloom_add_prefixes (uint64_t bloom_data [],
+ struct kdbus_bloom_parameter *bloom_params,
+ const char *parameter,
+ const char *value,
+ char separator)
+{
+ char buf[1024];
+ size_t size;
+
+ size = strlen(parameter) + strlen(value) + 1;
+ if (size > 1024)
+ return;
+
+ strcpy(stpcpy(stpcpy(buf, parameter), ":"), value);
+
+ for (;;)
+ {
+ char *last_sep;
+ last_sep = strrchr(buf, separator);
+ if (!last_sep || last_sep == buf)
+ break;
+
+ *last_sep = 0;
+ bloom_add_data (bloom_data, bloom_params, buf, last_sep-buf);
+ }
+}
+
+static int
+bus_message_setup_bloom(DBusMessage *msg,
+ struct kdbus_bloom_filter *bloom,
+ struct kdbus_bloom_parameter *bloom_params)
+{
+ void *data;
+ unsigned i;
+ //int ret;
+ const char *str;
+ DBusMessageIter args;
+
+ _dbus_assert(msg);
+ _dbus_assert(bloom);
+
+ data = bloom->data;
+ memset(data, 0, bloom_params->size);
+ bloom->generation = 0;
+
+ bloom_add_pair(data, bloom_params, "message-type",
+ dbus_message_type_to_string(dbus_message_get_type(msg))); //Fixme in systemd type invalid returns NULL but in dbus it returns "invalid"
+
+ str = dbus_message_get_interface(msg);
+ if (str)
+ bloom_add_pair(data, bloom_params, "interface", str);
+ str = dbus_message_get_member(msg);
+ if (str)
+ bloom_add_pair(data, bloom_params, "member", str);
+ str = dbus_message_get_path(msg);
+ if (str)
+ {
+ bloom_add_pair(data, bloom_params, "path", str);
+ bloom_add_pair(data, bloom_params, "path-slash-prefix", str);
+ bloom_add_prefixes(data, bloom_params, "path-slash-prefix", str, '/');
+ }
+
+ if(!dbus_message_iter_init(msg, &args))
+ return 0;
+
+ for (i = 0; i < 64; i++)
+ {
+ char type;
+ char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
+ char *e;
+
+ type = dbus_message_iter_get_arg_type(&args);
+ if (type != DBUS_TYPE_STRING &&
+ type != DBUS_TYPE_OBJECT_PATH &&
+ type != DBUS_TYPE_SIGNATURE)
+ break;
+
+ dbus_message_iter_get_basic(&args, &str);
+
+ e = stpcpy(buf, "arg");
+ if (i < 10)
+ *(e++) = '0' + (char) i;
+ else {
+ *(e++) = '0' + (char) (i / 10);
+ *(e++) = '0' + (char) (i % 10);
+ }
+
+ *e = 0;
+ bloom_add_pair(data, bloom_params, buf, str);
+
+ strcpy(e, "-dot-prefix");
+ bloom_add_prefixes(data, bloom_params, buf, str, '.');
+ strcpy(e, "-slash-prefix");
+ bloom_add_prefixes(data, bloom_params, buf, str, '/');
+
+ if(!dbus_message_iter_next(&args))
+ break;
+ }
+
+ return 0;
+}
+
+/**
+ * Checks if a string is a unique name or well known name.
+ *
+ * @param name - the string to check
+ * @param id - return pointer for unique id
+ * @returns 1 if the name is unique id, returns 0 if well-known name and -1 on error
+ */
+static int
+parse_name(const char *name,
+ uint64_t *id)
+{
+ char *endptr;
+ /* if name is unique name it must be converted to unique id */
+ if(strncmp(name, ":1.", 3) == 0)
+ {
+ errno = 0;
+ *id = strtoull(&name[3], &endptr, 10);
+ if (*id == 0 || *endptr != '\0' || errno == ERANGE)
+ return -1;
+ else
+ return 1;
+ }
+ else
+ return 0; //well known name
+}
+
+static int
+prepare_mfd (int memfd,
+ const char *header,
+ uint64_t header_size,
+ const char *body,
+ uint64_t body_size)
+{
+ const char *data[] = { header, body };
+ uint64_t count[] = { header_size, body_size };
+ int64_t wr;
+ int p;
+
+ _dbus_verbose("sending data via memfd\n");
+ for (p = 0; p < sizeof(data)/sizeof(data[0]); ++p)
+ {
+ while (count[p])
+ {
+ wr = write(memfd, data[p], count[p]);
+ if (wr < 0)
+ {
+ _dbus_verbose("writing to memfd failed: (%d) %m\n", errno);
+ return -1;
+ }
+ count[p] -= wr;
+ data[p] += wr;
+ }
+ }
+
+ // seal data - kdbus module needs it
+ if(fcntl(memfd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL) < 0)
+ {
+ _dbus_verbose("memfd sealing failed: %d (%m)\n", errno);
+ return -1;
+ }
+ return 0;
+}
+
+static int
+do_send_ioctl (DBusTransportKdbus *transport,
+ struct kdbus_cmd_send *cmd,
+ DBusMessage *message,
+ DBusError *error)
+{
+ int ret;
+ do {
+ ret = ioctl(transport->fd, KDBUS_CMD_SEND, cmd);
+ } while (ret != 0 && errno == EINTR);
+
+ if (ret == -1)
+ {
+ _dbus_verbose("kdbus error sending message: err %d (%m)\n", errno);
+
+ switch (errno)
+ {
+ case ENXIO: /* no such id on the bus */
+ case ESRCH:
+ dbus_set_error (error,
+ DBUS_ERROR_NAME_HAS_NO_OWNER,
+ "Name \"%s\" does not exist",
+ dbus_message_get_destination(message));
+ break;
+
+ case EADDRNOTAVAIL:
+ case ECONNRESET:
+ /* when well known name is not available on the bus */
+ if(dbus_message_get_auto_start (message))
+ dbus_set_error (error,
+ DBUS_ERROR_SERVICE_UNKNOWN,
+ "The name %s was not provided by any .service files",
+ dbus_message_get_destination(message));
+ else
+ dbus_set_error (error,
+ DBUS_ERROR_NAME_HAS_NO_OWNER,
+ "Name \"%s\" does not exist",
+ dbus_message_get_destination(message));
+ break;
+
+ case EMLINK:
+ dbus_set_error (error,
+ DBUS_ERROR_LIMITS_EXCEEDED,
+ NULL,
+ "The maximum number of pending replies per connection has been reached");
+ break;
+
+ case ENOBUFS:
+ case EXFULL:
+ dbus_set_error (error,
+ DBUS_ERROR_LIMITS_EXCEEDED,
+ "No space in receiver's buffer",
+ dbus_message_get_destination(message));
+ break;
+
+ default:
+ break;
+ }
+ }
+ return ret;
+}
+
+static void
+kdbus_close_message_at_offset (DBusTransportKdbus *transport, uint64_t offset)
+{
+ struct kdbus_item *item;
+ struct kdbus_msg *msg = (struct kdbus_msg *)((char*)dbus_transport_get_pool_pointer(&transport->base) + offset);
+
+ KDBUS_ITEM_FOREACH (item, msg, items)
+ {
+ if (item->type == KDBUS_ITEM_PAYLOAD_MEMFD)
+ close (item->memfd.fd);
+ }
+
+ kdbus_command_free (&transport->base, offset);
+}
+
+static void
+debug_c_str (const char *msg, const char *str, int len)
+{
+ int i;
+ fprintf(stderr, "%s\n", msg);
+ for (i = 0; i < len; i++)
+ {
+ fprintf(stderr, "%02x ", (unsigned char)str[i]);
+ if (i%16==15) fprintf(stderr, "\n");
+ }
+ fprintf(stderr, "\n");
+}
+
+static void
+debug_str (const char *msg, const DBusString *str)
+{
+ debug_c_str (msg, _dbus_string_get_const_data (str), _dbus_string_get_length (str));
+}
+
+static int
+kdbus_write_msg_internal(DBusTransportKdbus *transport,
+ DBusMessage *message,
+ const char *destination,
+ dbus_bool_t check_sync_reply)
+{
+ struct kdbus_cmd_send cmd = { };
+ struct kdbus_msg *msg = NULL;
+ struct kdbus_item *item;
+ uint64_t dst_id = KDBUS_DST_ID_BROADCAST;
+ const DBusString *header;
+ const DBusString *body;
+ uint64_t ret_size = -1;
+ uint64_t body_size = 0;
+ uint64_t header_size = 0;
+ int memfd = -1;
+ const int *unix_fds;
+ unsigned fds_count;
+ DBusError error;
+
+ dbus_error_init (&error);
+
+ // determine destination and destination id
+ if(destination)
+ {
+ dst_id = KDBUS_DST_ID_NAME;
+ switch (parse_name (destination, &dst_id))
+ {
+ case 0: /* well-known name - nothing to do */
+ break;
+ case 1: /* unique name */
+ destination = NULL;
+ break;
+ default: /* error */
+ _dbus_verbose("error: unique name is not a number: %s (%m)\n", destination);
+ return -1;
+ }
+ }
+
+ _dbus_message_get_network_data (message, &header, &body);
+ header_size = _dbus_string_get_length(header);
+ body_size = _dbus_string_get_length(body);
+ ret_size = header_size + body_size;
+
+ // check whether we can and should use memfd
+ if((dst_id != KDBUS_DST_ID_BROADCAST) && (ret_size > MEMFD_SIZE_THRESHOLD))
+ memfd = kdbus_acquire_memfd(transport, ret_size);
+
+ _dbus_message_get_unix_fds(message, &unix_fds, &fds_count);
+
+ // init basic message fields
+ msg = kdbus_init_msg(destination, dst_id, body_size, memfd >= 0, fds_count, transport);
+ if(msg == NULL)
+ {
+ _dbus_verbose("Can't allocate memory for new message\n");
+ ret_size = -1;
+ goto out;
+ }
+ msg->cookie = dbus_message_get_serial(message);
+ if (!dbus_message_get_auto_start (message))
+ msg->flags |= KDBUS_MSG_NO_AUTO_START;
+ if((dbus_message_get_no_reply(message) == FALSE) && (dst_id != KDBUS_DST_ID_BROADCAST))
+ {
+ long tv_sec, tv_usec;
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
+ msg->flags |= KDBUS_MSG_EXPECT_REPLY;
+ /* ms us ns */
+ msg->timeout_ns = (__u64)tv_sec * 1000ULL * 1000ULL * 1000ULL
+ + tv_usec * 1000ULL
+ + KDBUS_DEFAULT_TIMEOUT_NS;
+ }
+ else
+ msg->cookie_reply = dbus_message_get_reply_serial(message);
+
+ // build message contents
+ item = msg->items;
+
+ if(memfd >= 0)
+ {
+ if (prepare_mfd (memfd, _dbus_string_get_const_data (header), header_size,
+ _dbus_string_get_const_data (body), body_size) == -1)
+ {
+ ret_size = -1;
+ goto out;
+ }
+
+ item->type = KDBUS_ITEM_PAYLOAD_MEMFD;
+ item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_memfd);
+ item->memfd.size = ret_size;
+ item->memfd.fd = memfd;
+ }
+ else
+ {
+ _dbus_verbose("sending data by vec\n");
+ MSG_ITEM_BUILD_VEC(_dbus_string_get_const_data(header), header_size);
+
+ if(body_size)
+ {
+ const char* body_data;
+
+ body_data = _dbus_string_get_const_data(body);
+
+ if (-1 != debug)
+ {
+ debug_str ("Header to send:", header);
+ debug_str ("Body to send:", body);
+ }
+
+ while(body_size > KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE)
+ {
+ _dbus_verbose("attaching body part\n");
+ item = KDBUS_ITEM_NEXT(item);
+ MSG_ITEM_BUILD_VEC(body_data, KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE);
+ body_data += KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE;
+ body_size -= KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE;
+ }
+ if(body_size)
+ {
+ _dbus_verbose("attaching body part\n");
+ item = KDBUS_ITEM_NEXT(item);
+ MSG_ITEM_BUILD_VEC(body_data, body_size);
+ }
+ }
+ }
+
+ if(fds_count)
+ {
+ item = KDBUS_ITEM_NEXT(item);
+ item->type = KDBUS_ITEM_FDS;
+ item->size = KDBUS_ITEM_HEADER_SIZE + (sizeof(int) * fds_count);
+ memcpy(item->fds, unix_fds, sizeof(int) * fds_count);
+ }
+
+ if (destination)
+ {
+ item = KDBUS_ITEM_NEXT(item);
+ item->type = KDBUS_ITEM_DST_NAME;
+ item->size = KDBUS_ITEM_HEADER_SIZE + strlen(destination) + 1;
+ memcpy(item->str, destination, item->size - KDBUS_ITEM_HEADER_SIZE);
+ }
+ else if (dst_id == KDBUS_DST_ID_BROADCAST)
+ {
+ item = KDBUS_ITEM_NEXT(item);
+ item->type = KDBUS_ITEM_BLOOM_FILTER;
+ item->size = KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter) + transport->bloom.size);
+ bus_message_setup_bloom(message, &item->bloom_filter, &transport->bloom);
+ msg->flags |= KDBUS_MSG_SIGNAL;
+ }
+
+ cmd.size = sizeof(cmd);
+ cmd.msg_address = (uintptr_t)msg;
+
+ if (check_sync_reply)
+ cmd.flags = KDBUS_SEND_SYNC_REPLY;
+ else
+ cmd.flags = 0;
+
+ if (do_send_ioctl (transport, &cmd, message, &error) == -1)
+ {
+ if (check_sync_reply)
+ ret_size = -1;
+ else if (dbus_error_is_set (&error))
+ {
+ if (reply_with_error (error.name,
+ NULL,
+ error.message,
+ message,
+ transport->base.connection) == -1)
+ ret_size = -1;
+ }
+ goto out;
+ }
+
+ if (check_sync_reply)
+ {
+ kdbus_close_message_at_offset (transport, cmd.reply.offset);
+ }
+
+ out:
+ if(msg)
+ free(msg);
+ if(memfd >= 0)
+ close(memfd);
+
+ return ret_size;
+}
+
+/**
+ * Sends DBus message using kdbus.
+ * Handles broadcasts and unicast messages, and passing of Unix fds.
+ * Also can locally generate error replies on some error returned by kernel.
+ *
+ * TODO refactor to be more compact - maybe we can send header always as a payload vector
+ * and only message body as memfd if needed.
+ *
+ * @param transport Transport.
+ * @param message DBus message to be sent
+ * @param destination Destination of the message.
+ * @returns bytes sent or -1 if sending failed
+ */
+static int
+kdbus_write_msg(DBusTransportKdbus *transport,
+ DBusMessage *message,
+ const char *destination)
+{
+ return kdbus_write_msg_internal (transport, message, destination, FALSE);
+}
+
+/**
+ * Performs kdbus hello - registration on the kdbus bus
+ * needed to send and receive messages on the bus,
+ * and configures transport.
+ * As a result unique id on he bus is obtained.
+ *
+ * @see KDBUS_HELLO_* flags in kdbus.h
+ *
+ * @param transport transport structure
+ * @param registration_flags aditional flags to modify registration process
+ * @returns #TRUE on success
+ */
+static dbus_bool_t
+bus_register_kdbus(DBusTransportKdbus *transport,
+ dbus_uint32_t registration_flags,
+ DBusError *error)
+{
+ struct kdbus_cmd_hello *hello;
+ struct kdbus_item *item, *items;
+ __u64 hello_size;
+ __u64 item_size = 0;
+ __u64 receive_pool_size = RECEIVE_POOL_SIZE_DEFAULT_SIZE;
+ const char *env_pool;
+ const char conn_name[] = "libdbus-kdbus";
+ int conn_name_size = sizeof(conn_name);
+
+ hello_size = sizeof(struct kdbus_cmd_hello) + KDBUS_ITEM_SIZE(conn_name_size);
+ if(transport->activator != NULL)
+ {
+ item_size = KDBUS_ITEM_HEADER_SIZE + strlen(transport->activator) + 1;
+ hello_size += KDBUS_ALIGN8(item_size);
+ }
+
+ hello = alloca(hello_size);
+ memset(hello, 0, hello_size);
+
+ hello->flags = KDBUS_HELLO_ACCEPT_FD;
+ hello->attach_flags_send = _KDBUS_ATTACH_ANY;
+ hello->attach_flags_recv = KDBUS_ATTACH_NAMES;
+
+ env_pool = _dbus_getenv (RECEIVE_POOL_SIZE_ENV_VAR_NAME);
+ if(env_pool)
+ {
+ __u64 size;
+ unsigned int multiply = 1;
+ long int page_size;
+
+ page_size = sysconf(_SC_PAGESIZE);
+ if(page_size == -1)
+ {
+ size = 0;
+ goto finish;
+ }
+
+ errno = 0;
+ size = strtoul(env_pool, (char**)&env_pool, 10);
+ if((errno == EINVAL) || size == 0)
+ {
+ size = 0;
+ goto finish;
+ }
+
+ if(*env_pool == 'k')
+ {
+ multiply = 1024;
+ env_pool++;
+ }
+ else if (*env_pool == 'M')
+ {
+ multiply = 1024 * 1024;
+ env_pool++;
+ }
+
+ if(*env_pool != '\0')
+ {
+ size = 0;
+ goto finish;
+ }
+
+ receive_pool_size = size * multiply;
+
+ if((receive_pool_size > RECEIVE_POOL_SIZE_MAX_MBYTES * 1024 * 1024) ||
+ (receive_pool_size < RECEIVE_POOL_SIZE_MIN_KBYTES * 1024) ||
+ ((receive_pool_size & (page_size - 1)) != 0)) //pool size must be aligned to page size
+ size = 0;
+
+ finish:
+ if(size == 0)
+ {
+ _dbus_warn("%s value is invalid, default value %luB will be used.\n", RECEIVE_POOL_SIZE_ENV_VAR_NAME,
+ RECEIVE_POOL_SIZE_DEFAULT_SIZE);
+ _dbus_warn("Correct value must be between %ukB and %uMB and must be aligned to page size: %ldB.\n",
+ RECEIVE_POOL_SIZE_MIN_KBYTES, RECEIVE_POOL_SIZE_MAX_MBYTES, page_size);
+
+ receive_pool_size = RECEIVE_POOL_SIZE_DEFAULT_SIZE;
+ }
+ }
+
+ _dbus_verbose ("Receive pool size set to %llu.\n", receive_pool_size);
+ transport->receive_pool_size = receive_pool_size;
+ hello->pool_size = receive_pool_size;
+
+ item = hello->items;
+
+ if(transport->activator != NULL)
+ {
+ memcpy(item->str, transport->activator, strlen(transport->activator) + 1);
+ item->size = item_size;
+ item->type = KDBUS_ITEM_NAME;
+ hello->flags |= KDBUS_HELLO_ACTIVATOR;
+ item = KDBUS_ITEM_NEXT(item);
+ }
+
+ item->size = KDBUS_ITEM_HEADER_SIZE + conn_name_size;
+ item->type = KDBUS_ITEM_CONN_DESCRIPTION;
+ memcpy (item->str, conn_name, conn_name_size);
+
+ if (registration_flags & REGISTER_FLAG_MONITOR)
+ hello->flags |= KDBUS_HELLO_MONITOR;
+
+ hello->size = hello_size;
+
+ if (ioctl(transport->fd, KDBUS_CMD_HELLO, hello))
+ {
+ _dbus_verbose ("Failed to send hello (%d): %m\n",errno);
+ dbus_set_error(error, DBUS_ERROR_FAILED, "Hello failed: %d, %m", errno);
+ return FALSE;
+ }
+
+ transport->my_kdbus_id = hello->id;
+ memcpy(transport->bus_id, hello->id128, sizeof(transport->bus_id));
+
+ transport->my_DBus_unique_name = create_unique_name_from_unique_id (hello->id);
+
+ if(NULL == transport->my_DBus_unique_name)
+ {
+ dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "Hello post failed: %d, %m", errno);
+ return FALSE;
+ }
+
+
+ transport->kdbus_mmap_ptr = mmap(NULL, receive_pool_size, PROT_READ, MAP_SHARED, transport->fd, 0);
+ if (transport->kdbus_mmap_ptr == MAP_FAILED)
+ {
+ _dbus_verbose("Error when mmap: %m, %d",errno);
+ dbus_set_error(error, DBUS_ERROR_FAILED, "Hello mmap failed: %d, %m", errno);
+ free(transport->my_DBus_unique_name);
+ return FALSE;
+ }
+
+ _dbus_verbose("-- Our peer ID is: %llu\n", hello->id);
+ /* extract bloom parameters from items */
+ items = (void*)((uint8_t*)transport->kdbus_mmap_ptr + hello->offset);
+ KDBUS_FOREACH(item, items, hello->items_size) {
+ switch (item->type) {
+ case KDBUS_ITEM_BLOOM_PARAMETER:
+ /* FIXME validate ? */
+ transport->bloom = item->bloom_parameter;
+ break;
+ }
+ }
+
+ return TRUE;
+}
+
+static dbus_bool_t
+request_DBus_name (DBusTransport *transport,
+ DBusMessage *msg,
+ int *result,
+ DBusError *error)
+{
+ DBusString service_name_real;
+ const DBusString *service_name = &service_name_real;
+ char* name;
+ dbus_uint32_t flags;
+
+ if (!dbus_message_get_args (msg, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &flags,
+ DBUS_TYPE_INVALID))
+ return FALSE;
+
+ _dbus_string_init_const (&service_name_real, name);
+
+ if (!_dbus_validate_bus_name (service_name, 0,
+ _dbus_string_get_length (service_name)))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Requested bus name \"%s\" is not valid", name);
+
+ _dbus_verbose ("Attempt to acquire invalid service name\n");
+
+ return FALSE;
+ }
+
+ if (_dbus_string_get_byte (service_name, 0) == ':')
+ {
+ /* Not allowed; only base services can start with ':' */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot acquire a service starting with ':' such as \"%s\"", name);
+
+ _dbus_verbose ("Attempt to acquire invalid base service name \"%s\"", name);
+
+ return FALSE;
+ }
+
+ if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Connection is not allowed to own the service \"%s\"because "
+ "it is reserved for D-Bus' use only", DBUS_SERVICE_DBUS);
+ return FALSE;
+ }
+
+ *result = request_kdbus_name(transport, name, flags);
+ if(*result == -EPERM)
+ {
+ dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
+ "Kdbus don't allow %s to own the service \"%s\"",
+ ((DBusTransportKdbus*)transport)->my_DBus_unique_name, _dbus_string_get_const_data (service_name));
+ return FALSE;
+ }
+ else if(*result < 0)
+ {
+ dbus_set_error (error, DBUS_ERROR_FAILED , "Name \"%s\" could not be acquired, %d, %m", name, errno);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static dbus_bool_t
+release_DBus_name (DBusTransport *transport,
+ DBusMessage *msg,
+ int *result,
+ DBusError *error)
+{
+ const char *name;
+ DBusString service_name;
+
+ if (!dbus_message_get_args (msg, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID))
+ return FALSE;
+
+ _dbus_string_init_const (&service_name, name);
+
+ if (!_dbus_validate_bus_name (&service_name, 0,
+ _dbus_string_get_length (&service_name)))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Given bus name \"%s\" is not valid",
+ _dbus_string_get_const_data (&service_name));
+
+ _dbus_verbose ("Attempt to release invalid service name\n");
+ return FALSE;
+ }
+
+ if (_dbus_string_get_byte (&service_name, 0) == ':')
+ {
+ /* Not allowed; the base service name cannot be created or released */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot release a service starting with ':' such as \"%s\"",
+ _dbus_string_get_const_data (&service_name));
+
+ _dbus_verbose ("Attempt to release invalid base service name \"%s\"",
+ _dbus_string_get_const_data (&service_name));
+ return FALSE;
+ }
+
+ if (_dbus_string_equal_c_str (&service_name, DBUS_SERVICE_DBUS))
+ {
+ /* Not allowed; the base service name cannot be created or released */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot release the %s service because it is owned by the bus",
+ DBUS_SERVICE_DBUS);
+
+ _dbus_verbose ("Attempt to release service name \"%s\"",
+ DBUS_SERVICE_DBUS);
+ return FALSE;
+ }
+
+ *result = release_kdbus_name(transport, name);
+ if (*result < 0)
+ {
+ dbus_set_error (error, DBUS_ERROR_FAILED , "Name \"%s\" could not be released, %d, %m", name, errno);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+ * Adds a match rule to match broadcast messages going through the message bus.
+ * Do no affect messages addressed directly.
+ *
+ * copied a lot from systemd bus_add_match_internal_kernel()
+ *
+ * TODO add error reporting
+ *
+ * @param transport transport
+ * @param match rule
+ */
+static dbus_bool_t
+add_match_kdbus (DBusTransportKdbus *transport,
+ MatchRule *rule)
+{
+ struct kdbus_cmd_match *msg;
+ struct kdbus_item *item;
+ int i, sender = -1;
+ int sender_size = 0;
+ __u64 bloom_size;
+ __u64 rule_cookie;
+ uint64_t src_id = KDBUS_MATCH_ID_ANY;
+ uint64_t msg_size;
+ uint64_t *bloom;
+ dbus_bool_t need_bloom = FALSE;
+ dbus_bool_t standard_rule_also = TRUE;
+ char argument_buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix") +1];
+
+ const char *rule_string;
+ int rule_int;
+
+ rule_cookie = match_rule_get_cookie(rule);
+
+/*
+ * First check if it is org.freedesktop.DBus's NameOwnerChanged or any
+ * org.freedesktop.DBus combination that includes this,
+ * because it must be converted to special kdbus rule (kdbus has separate rules
+ * for kdbus(kernel) generated broadcasts).
+ */
+ rule_string = _match_rule_get_member (rule);
+ if (rule_string != NULL && strcmp(rule_string, "NameOwnerChanged"))
+ goto standard_rule;
+ rule_int = _match_rule_get_message_type (rule);
+ if ((rule_int != DBUS_MESSAGE_TYPE_INVALID) && (rule_int != DBUS_MESSAGE_TYPE_SIGNAL))
+ goto standard_rule;
+ rule_string = _match_rule_get_sender (rule);
+ if(rule_string != NULL)
+ {
+ sender = parse_name(rule_string, &src_id);
+ if(sender < 0)
+ return FALSE;
+ if(sender == 0)
+ {
+ if (strcmp(rule_string, DBUS_SERVICE_DBUS))
+ goto standard_rule;
+ else
+ standard_rule_also = FALSE;
+ }
+
+ if(sender > 0)
+ {
+ if(transport->daemon_unique_name)
+ {
+ uint64_t daemonsId;
+
+ daemonsId = strtoull(&transport->daemon_unique_name[3], NULL, 10);
+ if (src_id != daemonsId)
+ goto standard_rule;
+ else
+ standard_rule_also = FALSE;
+ }
+ }
+ }
+ rule_string = _match_rule_get_interface (rule);
+ if (rule_string != NULL)
+ {
+ if(strcmp(rule_string, DBUS_INTERFACE_DBUS))
+ goto standard_rule;
+ else
+ standard_rule_also = FALSE;
+ }
+ rule_string = _match_rule_get_path (rule);
+ if (rule_string != NULL)
+ {
+ if(strcmp(rule_string, DBUS_PATH_DBUS))
+ goto standard_rule;
+ else
+ standard_rule_also = FALSE;
+ }
+
+ //now we have to add kdbus rules related to well-known names
+ msg_size = KDBUS_ALIGN8(offsetof(struct kdbus_cmd_match, items) +
+ offsetof(struct kdbus_item, name_change) +
+ offsetof(struct kdbus_notify_name_change, name));
+
+ msg = alloca(msg_size);
+ if(msg == NULL)
+ {
+ errno = ENOMEM;
+ return FALSE;
+ }
+
+ msg->cookie = rule_cookie;
+ msg->size = msg_size;
+ msg->flags = 0;
+
+ /* first match against any name change */
+ item = msg->items;
+ item->size =
+ offsetof(struct kdbus_item, name_change) +
+ offsetof(struct kdbus_notify_name_change, name); //TODO name from arg0 can be added here (if present in the rule)
+ item->name_change.old_id.id = KDBUS_MATCH_ID_ANY; //TODO can be replaced with arg0 or arg1 from rule (if present)
+ item->name_change.new_id.id = KDBUS_MATCH_ID_ANY; //TODO can be replaced with arg0 or arg2 from rule (if present)
+
+ item->type = KDBUS_ITEM_NAME_CHANGE;
+ if(ioctl(transport->fd, KDBUS_CMD_MATCH_ADD, msg))
+ {
+ _dbus_verbose("Failed adding match rule for name changes for daemon, error: %d, %m\n", errno);
+ return FALSE;
+ }
+
+ /* then match against any name add */
+ item->type = KDBUS_ITEM_NAME_ADD;
+ if(ioctl(transport->fd, KDBUS_CMD_MATCH_ADD, msg))
+ {
+ _dbus_verbose("Failed adding match rule for name adding for daemon, error: %d, %m\n", errno);
+ return FALSE;
+ }
+
+ /* then match against any name remove */
+ item->type = KDBUS_ITEM_NAME_REMOVE;
+ if(ioctl(transport->fd, KDBUS_CMD_MATCH_ADD, msg))
+ {
+ _dbus_verbose("Failed adding match rule for name removal for daemon, error: %d, %m\n", errno);
+ return FALSE;
+ }
+
+ //now we add kdbus rules related to unique names
+ msg_size = KDBUS_ALIGN8(offsetof(struct kdbus_cmd_match, items) +
+ offsetof(struct kdbus_item, id_change) +
+ sizeof(struct kdbus_notify_id_change));
+
+ msg = alloca(msg_size);
+ if(msg == NULL)
+ {
+ errno = ENOMEM;
+ return FALSE;
+ }
+
+ msg->cookie = rule_cookie;
+ msg->size = msg_size;
+ msg->flags = 0;
+
+ item = msg->items;
+ item->size =
+ offsetof(struct kdbus_item, id_change) +
+ sizeof(struct kdbus_notify_id_change);
+ item->id_change.id = KDBUS_MATCH_ID_ANY; //TODO can be replaced with arg0 or arg1 or arg2 from rule (if present and applicable)
+
+ item->type = KDBUS_ITEM_ID_ADD;
+ if(ioctl(transport->fd, KDBUS_CMD_MATCH_ADD, msg))
+ {
+ _dbus_verbose("Failed adding match rule for adding id for daemon, error: %d, %m\n", errno);
+ return FALSE;
+ }
+
+ item->type = KDBUS_ITEM_ID_REMOVE;
+ if(ioctl(transport->fd, KDBUS_CMD_MATCH_ADD, msg))
+ {
+ _dbus_verbose("Failed adding match rule for id removal for daemon, error: %d, %m\n", errno);
+ return FALSE;
+ }
+
+ _dbus_verbose("Added match rule for kernel correctly.\n");
+
+ if(standard_rule_also == FALSE)
+ return TRUE;
+
+
+ /*
+ * standard rule - registered in general way, for non-kernel broadcasts
+ * kdbus don't use it to check kdbus(kernel) generated broadcasts
+ */
+standard_rule:
+ bloom_size = transport->bloom.size;
+ bloom = alloca(bloom_size);
+ if(bloom == NULL)
+ return FALSE;
+ memset(bloom, 0, bloom_size);
+
+ msg_size = sizeof(struct kdbus_cmd_match);
+
+ rule_int = _match_rule_get_message_type (rule);
+ if (rule_int != DBUS_MESSAGE_TYPE_INVALID)
+ {
+ bloom_add_pair(bloom, &transport->bloom, "message-type", dbus_message_type_to_string(rule_int));
+ _dbus_verbose("Adding type %s \n", dbus_message_type_to_string(rule_int));
+ need_bloom = TRUE;
+ }
+
+ rule_string = _match_rule_get_sender (rule);
+ if(rule_string != NULL)
+ {
+ sender = parse_name(rule_string, &src_id);
+ if(sender < 0)
+ return FALSE;
+
+ if(sender > 0) // unique_id
+ msg_size += KDBUS_ITEM_SIZE(sizeof(uint64_t));
+ else // well-known name
+ {
+ sender_size = strlen(rule_string) + 1;
+ msg_size += KDBUS_ITEM_SIZE(sender_size);
+ }
+ }
+
+ rule_string = _match_rule_get_interface (rule);
+ if (rule_string != NULL)
+ {
+ bloom_add_pair(bloom, &transport->bloom, "interface", rule_string);
+ need_bloom = TRUE;
+ _dbus_verbose("Adding interface %s \n", rule_string);
+ }
+
+ rule_string = _match_rule_get_member (rule);
+ if (rule_string != NULL)
+ {
+ bloom_add_pair(bloom, &transport->bloom, "member", rule_string);
+ need_bloom = TRUE;
+ _dbus_verbose("Adding member %s \n", rule_string);
+ }
+
+ rule_string = _match_rule_get_path (rule);
+ if (rule_string != NULL)
+ {
+ bloom_add_pair(bloom, &transport->bloom, "path", rule_string);
+ need_bloom = TRUE;
+ _dbus_verbose("Adding path %s \n", rule_string);
+ }
+
+ rule_string = _match_rule_get_path_namespace (rule);
+ if (rule_string != NULL)
+ {
+ bloom_add_pair(bloom, &transport->bloom, "path-slash-prefix", rule_string);
+ need_bloom = TRUE;
+ _dbus_verbose("Adding path-slash-prefix %s \n", rule_string);
+ }
+
+ rule_int = _match_rule_get_args_len (rule);
+ for (i = 0; i < rule_int; i++)
+ {
+ rule_string = _match_rule_get_args (rule, i);
+ if (rule_string != NULL)
+ {
+ unsigned int rule_arg_lens = _match_rule_get_arg_lens (rule, i);
+ if(rule_arg_lens & MATCH_ARG_IS_PATH)
+ {
+ sprintf(argument_buf, "arg%d-slash-prefix", i);
+ bloom_add_prefixes(bloom, &transport->bloom, argument_buf, rule_string, '/');
+ }
+ else if (rule_arg_lens & MATCH_ARG_NAMESPACE)
+ {
+ sprintf(argument_buf, "arg%d-dot-prefix", i);
+ bloom_add_prefixes(bloom, &transport->bloom, argument_buf, rule_string, '.');
+ }
+ else
+ {
+ sprintf(argument_buf, "arg%d", i);
+ bloom_add_pair(bloom, &transport->bloom, argument_buf, rule_string);
+ }
+ need_bloom = TRUE;
+ }
+ }
+
+ if(need_bloom)
+ msg_size += KDBUS_ITEM_HEADER_SIZE + bloom_size;
+
+ msg = alloca(msg_size);
+ if(msg == NULL)
+ return FALSE;
+
+ msg->cookie = rule_cookie;
+ msg->size = msg_size;
+ msg->flags = 0;
+ item = msg->items;
+
+ if(!sender)
+ {
+ const char *rule_sender = _match_rule_get_sender (rule);
+ item->type = KDBUS_ITEM_NAME;
+ item->size = KDBUS_ITEM_HEADER_SIZE + sender_size;
+ memcpy(item->str, rule_sender, sender_size);
+ item = KDBUS_ITEM_NEXT(item);
+ _dbus_verbose("Adding sender %s \n", rule_sender);
+ }
+
+ if(src_id != KDBUS_MATCH_ID_ANY)
+ {
+ item->type = KDBUS_ITEM_ID;
+ item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(__u64);
+ item->id = src_id;
+ item = KDBUS_ITEM_NEXT(item);
+ _dbus_verbose("Adding src_id %llu \n", (unsigned long long)src_id);
+ }
+
+ if(need_bloom)
+ {
+ item->type = KDBUS_ITEM_BLOOM_MASK;
+ item->size = KDBUS_ITEM_HEADER_SIZE + bloom_size;
+ memcpy(item->data, bloom, bloom_size);
+ }
+
+ if(ioctl(transport->fd, KDBUS_CMD_MATCH_ADD, msg))
+ {
+ _dbus_verbose("Failed adding match bus rule cookie %llu,\nerror: %d, %m\n", rule_cookie, errno);
+ return FALSE;
+ }
+
+ _dbus_verbose("Added match bus rule %llu\n", rule_cookie);
+ return TRUE;
+}
+
+static int
+capture_org_freedesktop_DBus_Hello (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ DBusMessageIter args;
+ dbus_uint32_t registration_flags = 0;
+
+ dbus_message_iter_init(message, &args);
+ if (dbus_message_iter_get_arg_type(&args) == DBUS_TYPE_UINT32)
+ dbus_message_iter_get_basic(&args, ®istration_flags);
+
+ if(!bus_register_kdbus(transport, registration_flags, error))
+ goto out;
+
+ if(!reply_1_data(message, DBUS_TYPE_STRING, &transport->my_DBus_unique_name, transport->base.connection))
+ return 0; //on success we can not free name
+
+out:
+ free(transport->my_DBus_unique_name);
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_RequestName (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ int result;
+
+ if(!request_DBus_name(&transport->base, message, &result, error))
+ return -1;
+
+ return reply_1_data(message, DBUS_TYPE_UINT32, &result,
+ transport->base.connection);
+}
+
+static int
+capture_org_freedesktop_DBus_ReleaseName (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ int result;
+
+ if(!release_DBus_name(&transport->base, message, &result, error))
+ return -1;
+
+ return reply_1_data(message, DBUS_TYPE_UINT32, &result,
+ transport->base.connection);
+}
+
+static int
+capture_org_freedesktop_DBus_AddMatch (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ const char *arg;
+ DBusString arg_str;
+ MatchRule *rule = NULL;
+ DBusConnection *connection = transport->base.connection;
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &arg,
+ DBUS_TYPE_INVALID))
+ goto failed;
+
+ _dbus_string_init_const (&arg_str, arg);
+
+ rule = match_rule_parse (connection, &arg_str, error);
+ if (rule == NULL)
+ goto failed;
+
+ if (!matchmaker_add_rule (transport->matchmaker, rule))
+ {
+ dbus_set_error_const (error, DBUS_ERROR_NO_MEMORY, "No memory to store match rule");
+ goto failed;
+ }
+
+ if(!add_match_kdbus (transport, rule))
+ {
+ dbus_set_error (error, _dbus_error_from_errno (errno), "Could not add match rule, %s",
+ _dbus_strerror_from_errno ());
+ goto failed;
+ }
+
+ match_rule_unref (rule);
+ return reply_ack(message, connection);
+
+failed:
+ if(rule)
+ match_rule_unref (rule);
+ _dbus_verbose("Error during AddMatch in lib: %s, %s\n", error->name, error->message);
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_RemoveMatch (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ const char *arg;
+ DBusString arg_str;
+ MatchRule *rule = NULL;
+ DBusConnection *connection = transport->base.connection;
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &arg,
+ DBUS_TYPE_INVALID))
+ goto failed_remove;
+
+ _dbus_string_init_const (&arg_str, arg);
+
+ rule = match_rule_parse (connection, &arg_str, error);
+ if (rule == NULL)
+ goto failed_remove;
+
+ if (!kdbus_remove_match (&transport->base, matchmaker_get_rules_list (transport->matchmaker, rule),
+ transport->my_DBus_unique_name, rule, error))
+ goto failed_remove;
+
+ if (!matchmaker_remove_rule_by_value (transport->matchmaker, rule, error))
+ goto failed_remove;
+
+ match_rule_unref (rule);
+ return reply_ack(message, connection);
+
+failed_remove:
+ if (rule)
+ match_rule_unref (rule);
+ _dbus_verbose("Error during RemoveMatch in lib: %s, %s\n", error->name, error->message);
+ return -1;
+}
+
+static int
+get_connection_info_by_name (DBusMessage *message,
+ DBusError *error,
+ struct nameInfo *info,
+ DBusTransport *transport,
+ const char *name,
+ dbus_bool_t getLabel)
+{
+ int ret;
+ if (!dbus_validate_bus_name (name, error))
+ return -1;
+
+ if ((ret = kdbus_NameQuery (name, transport, info)) < 0)
+ {
+ if (-ESRCH == ret || -ENXIO == ret)
+ dbus_set_error (error, DBUS_ERROR_NAME_HAS_NO_OWNER,
+ "Could not get owner of name '%s': no such name", name);
+ else
+ dbus_set_error (error, DBUS_ERROR_FAILED,
+ "Unable to query name %s, returned %d, errno = %d (%m).",
+ name, ret, errno);
+ return -1;
+ }
+ if (!getLabel)
+ free (info->sec_label);
+ info->sec_label = NULL;
+ if (info->flags & KDBUS_HELLO_ACTIVATOR)
+ {
+ dbus_set_error (error, DBUS_ERROR_NAME_HAS_NO_OWNER,
+ "Could not get owner of name '%s'", name);
+ /* we return ESRCH - this is an indicator that name has an activator */
+ return -ESRCH;
+ }
+ return 0;
+}
+
+/* This local function handles common case for org.freedesktop.DBus method handlers:
+ * 1. gets string argument from incoming message;
+ * 2. gets connection info for such name.
+ * Note: if getLabel argument is set to TRUE, the caller must free info.sec_label.
+ */
+static int
+get_connection_info_from_message_argument (DBusMessage *message,
+ DBusError *error,
+ struct nameInfo *info,
+ DBusTransport *transport,
+ dbus_bool_t getLabel)
+{
+ const char *arg;
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &arg,
+ DBUS_TYPE_INVALID))
+ return -1;
+
+ return get_connection_info_by_name (message, error, info, transport, arg, getLabel);
+}
+
+static int
+capture_org_freedesktop_DBus_GetConnectionCredentials (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ DBusMessage *reply = NULL;
+ DBusConnection *conn = transport->base.connection;
+ DBusMessageIter reply_iter;
+ DBusMessageIter array_iter;
+ struct nameInfo info;
+
+ if (get_connection_info_from_message_argument (message, error, &info, &transport->base, TRUE) != 0)
+ return -1;
+
+ reply = _dbus_asv_new_method_return (message, &reply_iter, &array_iter);
+ if (reply == NULL)
+ return -1;
+
+ /* we can't represent > 32-bit pids; if your system needs them, please
+ * add ProcessID64 to the spec or something */
+ if (info.processId <= _DBUS_UINT32_MAX)
+ {
+ if (!_dbus_asv_add_uint32 (&array_iter, "ProcessID", info.processId))
+ goto oom;
+ }
+ /* we can't represent > 32-bit uids; if your system needs them, please
+ * add UnixUserID64 to the spec or something */
+ if (info.userId <= _DBUS_UINT32_MAX)
+ {
+ if (!_dbus_asv_add_uint32 (&array_iter, "UnixUserID", info.userId))
+ goto oom;
+ }
+
+ if (info.sec_label != NULL)
+ {
+ dbus_bool_t res = _dbus_asv_add_array_of_bytes (&array_iter, "LinuxSecurityLabel",
+ info.sec_label,
+ strlen(info.sec_label)+1);
+
+ free(info.sec_label);
+
+ if (!res)
+ goto oom;
+ }
+
+ if (!_dbus_asv_close (&reply_iter, &array_iter))
+ goto oom;
+
+ if (!dbus_message_set_sender (reply, DBUS_SERVICE_DBUS))
+ goto oom;
+
+ if (!add_message_to_received (reply, conn))
+ goto oom;
+
+ return 0;
+
+oom:
+ _dbus_asv_abandon (&reply_iter, &array_iter);
+ dbus_message_unref (reply);
+
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_GetConnectionSELinuxSecurityContext (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+
+ if (get_connection_info_from_message_argument (message, error, &info, &transport->base, TRUE) != 0)
+ return -1;
+
+ if (info.sec_label != NULL)
+ {
+ int ret = reply_fixed_array (message, DBUS_TYPE_BYTE,
+ info.sec_label,
+ strlen(info.sec_label)+1,
+ transport->base.connection);
+
+ free(info.sec_label);
+ return ret;
+ }
+ else
+ {
+ dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED, "Operation not supported");
+ }
+
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_GetConnectionUnixProcessID (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+ dbus_uint32_t processId;
+
+ if (get_connection_info_from_message_argument (message, error, &info, &transport->base, FALSE) != 0 ||
+ info.processId > _DBUS_UINT32_MAX)
+ return -1;
+
+ processId = info.processId;
+
+ return reply_1_data (message, DBUS_TYPE_UINT32, &processId, transport->base.connection);
+}
+
+static int
+capture_org_freedesktop_DBus_GetConnectionUnixUser (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+ dbus_uint32_t userId;
+
+ if (get_connection_info_from_message_argument (message, error, &info, &transport->base, FALSE) != 0 ||
+ info.userId > _DBUS_UINT32_MAX)
+ return -1;
+
+ userId = info.userId;
+
+ return reply_1_data (message, DBUS_TYPE_UINT32, &userId, transport->base.connection);
+}
+
+static int
+capture_org_freedesktop_DBus_GetId (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ char bus_id[sizeof(transport->bus_id)*2+1];
+ char *bus_id_ptr = bus_id;
+ int i = 0;
+ for (; i < sizeof(transport->bus_id); i++)
+ sprintf(bus_id + 2*i, "%02x", transport->bus_id[i]);
+ return reply_1_data (message, DBUS_TYPE_STRING, &bus_id_ptr, transport->base.connection);
+}
+
+static int
+capture_org_freedesktop_DBus_GetNameOwner (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+ char *unique_name;
+ int ret;
+ const char *arg;
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &arg,
+ DBUS_TYPE_INVALID))
+ return -1;
+
+ if (strcmp (arg, DBUS_SERVICE_DBUS) == 0)
+ {
+ if (-1 == asprintf(&unique_name, "%s", DBUS_SERVICE_DBUS))
+ return -1;
+ }
+ else
+ {
+ if (get_connection_info_by_name (message, error, &info, &transport->base, arg, FALSE) != 0)
+ return -1;
+
+ unique_name = create_unique_name_from_unique_id (info.uniqueId);
+ if (NULL == unique_name)
+ return -1;
+ }
+
+ ret = reply_1_data (message, DBUS_TYPE_STRING, &unique_name, transport->base.connection);
+
+ free(unique_name);
+
+ return ret;
+}
+
+static int
+reply_listNames (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error,
+ dbus_uint64_t flags)
+{
+ DBusMessage *reply = NULL;
+ dbus_uint64_t prev_id = 0;
+
+ /* First, get the list from kdbus */
+
+ struct kdbus_info *name_list, *name;
+ struct kdbus_cmd_list cmd = {
+ .size = sizeof(cmd)
+ };
+ int ret;
+ DBusMessageIter iter;
+ DBusMessageIter array_iter;
+
+ cmd.flags = flags;
+ ret = ioctl (transport->fd, KDBUS_CMD_LIST, &cmd);
+ if (ret < 0)
+ {
+ dbus_set_error (error, DBUS_ERROR_FAILED, "Error listing names");
+ return -1;
+ }
+
+ /* Compose the reply on the fly */
+ reply = dbus_message_new_method_return (message);
+ if (reply == NULL)
+ goto oom;
+
+ dbus_message_iter_init_append (reply, &iter);
+ if (!dbus_message_iter_open_container (&iter,
+ DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING,
+ &array_iter))
+ goto oom_reply;
+
+ name_list = (struct kdbus_info *)((char*)dbus_transport_get_pool_pointer(&transport->base) + cmd.offset);
+
+ KDBUS_FOREACH (name, name_list, cmd.list_size)
+ {
+ struct kdbus_item *item;
+
+ if ((flags & KDBUS_LIST_UNIQUE) && name->id != prev_id)
+ {
+ dbus_bool_t res;
+
+ char *unique_name = create_unique_name_from_unique_id (name->id);
+
+ if (NULL == unique_name)
+ goto oom_iterator;
+
+ res = dbus_message_iter_append_basic (&array_iter,
+ DBUS_TYPE_STRING,
+ &unique_name);
+ free(unique_name);
+
+ if (!res)
+ goto oom_iterator;
+ }
+
+ KDBUS_ITEM_FOREACH (item, name, items)
+ {
+ if (item->type == KDBUS_ITEM_OWNED_NAME)
+ {
+ DBusError local_error;
+ char *name_ptr = item->name.name;
+
+ dbus_error_init ( &local_error );
+ if (!dbus_validate_bus_name (name_ptr, &local_error))
+ continue;
+
+ if (flags & KDBUS_LIST_QUEUED)
+ name_ptr = create_unique_name_from_unique_id (name->id);
+
+ if (NULL == name_ptr)
+ goto oom_iterator;
+
+ if (!dbus_message_iter_append_basic (&array_iter,
+ DBUS_TYPE_STRING,
+ &name_ptr))
+ goto oom_iterator;
+
+ if (flags & KDBUS_LIST_QUEUED)
+ free (name_ptr);
+ }
+ }
+ }
+
+ if (!dbus_message_iter_close_container (&iter, &array_iter))
+ goto oom_reply;
+
+ if (!dbus_message_set_sender (reply, DBUS_SERVICE_DBUS))
+ goto oom_reply;
+
+ /* Finally, send the reply */
+ if (!add_message_to_received (reply, transport->base.connection))
+ goto oom_reply;
+
+ return 0;
+
+oom_iterator:
+ dbus_message_iter_abandon_container (&iter, &array_iter);
+
+oom_reply:
+ dbus_message_unref (reply);
+oom:
+ kdbus_command_free (&transport->base, cmd.offset);
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_ListActivatableNames (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ return reply_listNames (transport, message, error, KDBUS_LIST_ACTIVATORS);
+}
+
+static int
+capture_org_freedesktop_DBus_ListNames (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ return reply_listNames (transport, message, error, KDBUS_LIST_UNIQUE | KDBUS_LIST_NAMES);
+}
+
+static int
+capture_org_freedesktop_DBus_ListQueuedOwners (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+
+ if (get_connection_info_from_message_argument (message, error, &info, &transport->base, FALSE) != 0)
+ return -1;
+
+ return reply_listNames (transport, message, error, KDBUS_LIST_QUEUED);
+}
+
+static int
+capture_org_freedesktop_DBus_NameHasOwner (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+ dbus_bool_t result = TRUE;
+
+ if (get_connection_info_from_message_argument (message, error, &info, &transport->base, FALSE) != 0)
+ {
+ if (dbus_error_is_set (error) && dbus_error_has_name (error, DBUS_ERROR_NAME_HAS_NO_OWNER))
+ {
+ result = FALSE;
+ dbus_error_free (error);
+ }
+ else
+ return -1;
+ }
+
+ return reply_1_data (message, DBUS_TYPE_BOOLEAN, &result, transport->base.connection);
+}
+
+static int
+capture_org_freedesktop_DBus_ReloadConfig (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ DBusMessageIter iter;
+ DBusMessage *reply = NULL;
+
+ dbus_message_iter_init (message, &iter);
+ if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRUCT)
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Call to 'ReloadConfig' has wrong args");
+ return -1;
+ }
+
+ reply = dbus_message_new_method_return(message);
+ if(reply == NULL)
+ return -1;
+
+ if (!dbus_message_set_sender (reply, DBUS_SERVICE_DBUS))
+ goto oom;
+
+ if (!add_message_to_received (reply, transport->base.connection))
+ goto oom;
+
+ return 0;
+
+oom:
+ dbus_message_unref (reply);
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_StartServiceByName (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ struct nameInfo info;
+ char *name;
+ dbus_uint32_t flags; /* Spec says: not used, but we check the syntax anyway */
+ int ret;
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &flags,
+ DBUS_TYPE_INVALID))
+ return -1;
+
+ if (0 == strncmp(name, DBUS_SERVICE_DBUS, strlen(DBUS_SERVICE_DBUS)+1) ||
+ (ret = get_connection_info_by_name (message, error, &info, &transport->base,
+ name, FALSE)) == 0)
+ {
+ dbus_uint32_t status = DBUS_START_REPLY_ALREADY_RUNNING;
+ return reply_1_data (message, DBUS_TYPE_UINT32, &status, transport->base.connection);
+ }
+ else if (-ESRCH == ret) /* there is an activator */
+ {
+ DBusMessage *sub_message;
+
+ /* if we are here, then we probably have error set - free place for possible real error */
+ dbus_error_free (error);
+
+ /* send method call to org.freedesktop.DBus.Peer.Ping */
+ sub_message = dbus_message_new_method_call (name, "/", DBUS_INTERFACE_PEER, "Ping");
+ if (sub_message == NULL)
+ return -1;
+
+ /* The serial number here is set to -1. A message needs a valid serial number.
+ * We do not have access to connection's serial numbers counter, so we need to make up one.
+ * -1 is the last valid serial, so we hope that we'll never get there, especially with 64-bit
+ * kdbus cookies.
+ */
+ dbus_message_set_serial (sub_message, -1);
+
+ if (kdbus_write_msg_internal (transport, sub_message, name, FALSE) == -1)
+ return -1;
+ else
+ {
+ dbus_uint32_t status = DBUS_START_REPLY_SUCCESS;
+ return reply_1_data (message, DBUS_TYPE_UINT32, &status, transport->base.connection);
+ }
+ }
+ else
+ dbus_set_error (error,
+ DBUS_ERROR_SERVICE_UNKNOWN,
+ "The name %s was not provided by any .service files",
+ name);
+
+ return -1;
+}
+
+static int
+capture_org_freedesktop_DBus_UpdateActivationEnvironment (DBusTransportKdbus *transport,
+ DBusMessage *message,
+ DBusError *error)
+{
+ dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
+ "'%s' method not supported", dbus_message_get_member(message));
+ return -1;
+}
+
+typedef int (*CaptureHandler)(DBusTransportKdbus *, DBusMessage *, DBusError *);
+struct CaptureHandlers {
+ const char *method_name;
+ CaptureHandler handler;
+};
+
+#define HANDLER_ELEMENT(x) {#x, capture_org_freedesktop_DBus_##x}
+
+/* This is to cut the code to parts, and keep it organized:
+ * an array of elements of type, as in example:
+ * { "RequestName", capture_org_freedesktop_DBus_RequestName }
+ * That is, a method of name RequestName will be handled by capture_org_freedesktop_DBus_RequestName().
+ */
+static struct CaptureHandlers capture_handlers[] =
+{
+// "Hello" is handled separately
+// HANDLER_ELEMENT(Hello),
+ HANDLER_ELEMENT (RequestName),
+ HANDLER_ELEMENT (ReleaseName),
+ HANDLER_ELEMENT (AddMatch),
+ HANDLER_ELEMENT (RemoveMatch),
+ HANDLER_ELEMENT (GetConnectionCredentials),
+ HANDLER_ELEMENT (GetConnectionSELinuxSecurityContext),
+ HANDLER_ELEMENT (GetConnectionUnixProcessID),
+ HANDLER_ELEMENT (GetConnectionUnixUser),
+ HANDLER_ELEMENT (GetId),
+ HANDLER_ELEMENT (GetNameOwner),
+ HANDLER_ELEMENT (ListActivatableNames),
+ HANDLER_ELEMENT (ListNames),
+ HANDLER_ELEMENT (ListQueuedOwners),
+ HANDLER_ELEMENT (NameHasOwner),
+ HANDLER_ELEMENT (ReloadConfig),
+ HANDLER_ELEMENT (StartServiceByName),
+ HANDLER_ELEMENT (UpdateActivationEnvironment)
+};
+
+/**
+ * Looks over messages sent to org.freedesktop.DBus. Hello message, which performs
+ * registration on the bus, is captured as it must be locally converted into
+ * appropriate ioctl. AddMatch and RemoveMatch are captured to store match rules
+ * locally in case of false positive result of kdbus bloom filters, but after
+ * being read they are passed to org.freedesktop.DBus to register these rules
+ * in kdbus.
+ * All the rest org.freedesktop.DBus methods are left untouched
+ * and they are sent to dbus-daemon in the same way as every other messages.
+ *
+ * @param transport Transport
+ * @param message Message being sent.
+ * @returns 1 if message is not captured and should be passed to daemon
+ * 0 if message was handled locally and correctly (it includes proper return of error reply),
+ * -1 message to org.freedesktop.DBus was not handled correctly.
+ */
+static int
+capture_org_freedesktop_DBus(DBusTransportKdbus *transport,
+ const char *destination,
+ DBusMessage *message)
+{
+ int ret = 1;
+ if(!strcmp(destination, DBUS_SERVICE_DBUS))
+ {
+ if(!strcmp(dbus_message_get_interface(message), DBUS_INTERFACE_DBUS))
+ {
+ DBusError error;
+ const char *member = dbus_message_get_member(message);
+
+ dbus_error_init(&error);
+
+ ret = -1;
+ if(!strcmp(member, "Hello"))
+ {
+ ret = capture_org_freedesktop_DBus_Hello (transport, message, &error);
+ }
+ else
+ {
+ int i = 0;
+ int handlers_size = sizeof(capture_handlers)/sizeof(capture_handlers[0]);
+
+ while (i < handlers_size && strcmp(member, capture_handlers[i].method_name) != 0)
+ i++;
+
+ if (i < handlers_size)
+ {
+ ret = capture_handlers[i].handler (transport, message, &error);
+ }
+ else
+ {
+ dbus_set_error (&error, DBUS_ERROR_UNKNOWN_METHOD,
+ "org.freedesktop.DBus does not understand message %s", member);
+ }
+ }
+
+ if (ret != 0 && dbus_error_is_set (&error))
+ {
+ ret = reply_with_error((char*)error.name, NULL, error.message, message,
+ transport->base.connection);
+ dbus_error_free(&error);
+ }
+ }
+ }
+
+ return ret; //send message to daemon
+}
+
+#if KDBUS_MSG_DECODE_DEBUG == 1
+static const char
+*msg_id(uint64_t id)
+{
+ char buf[64];
+ const char* const_ptr;
+
+ if (id == 0)
+ return "KERNEL";
+ if (id == ~0ULL)
+ return "BROADCAST";
+
+ sprintf(buf, "%llu", (unsigned long long)id);
+
+ const_ptr = buf;
+ return const_ptr;
+}
+#endif
+struct kdbus_enum_table {
+ long long id;
+ const char *name;
+};
+#define _STRINGIFY(x) #x
+#define STRINGIFY(x) _STRINGIFY(x)
+#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
+#define TABLE(what) static struct kdbus_enum_table kdbus_table_##what[]
+#define ENUM(_id) { .id=_id, .name=STRINGIFY(_id) }
+#define LOOKUP(what) \
+ const char *enum_##what(long long id) { \
+ size_t i; \
+ for (i = 0; i < ELEMENTSOF(kdbus_table_##what); i++) \
+ if (id == kdbus_table_##what[i].id) \
+ return kdbus_table_##what[i].name; \
+ return "UNKNOWN"; \
+ }
+const char *enum_MSG(long long id);
+TABLE(MSG) = {
+ ENUM(_KDBUS_ITEM_NULL),
+ ENUM(KDBUS_ITEM_PAYLOAD_VEC),
+ ENUM(KDBUS_ITEM_PAYLOAD_OFF),
+ ENUM(KDBUS_ITEM_PAYLOAD_MEMFD),
+ ENUM(KDBUS_ITEM_FDS),
+ ENUM(KDBUS_ITEM_BLOOM_PARAMETER),
+ ENUM(KDBUS_ITEM_BLOOM_FILTER),
+ ENUM(KDBUS_ITEM_DST_NAME),
+ ENUM(KDBUS_ITEM_CREDS),
+ ENUM(KDBUS_ITEM_PID_COMM),
+ ENUM(KDBUS_ITEM_TID_COMM),
+ ENUM(KDBUS_ITEM_EXE),
+ ENUM(KDBUS_ITEM_CMDLINE),
+ ENUM(KDBUS_ITEM_CGROUP),
+ ENUM(KDBUS_ITEM_CAPS),
+ ENUM(KDBUS_ITEM_SECLABEL),
+ ENUM(KDBUS_ITEM_AUDIT),
+ ENUM(KDBUS_ITEM_CONN_DESCRIPTION),
+ ENUM(KDBUS_ITEM_NAME),
+ ENUM(KDBUS_ITEM_TIMESTAMP),
+ ENUM(KDBUS_ITEM_NAME_ADD),
+ ENUM(KDBUS_ITEM_NAME_REMOVE),
+ ENUM(KDBUS_ITEM_NAME_CHANGE),
+ ENUM(KDBUS_ITEM_ID_ADD),
+ ENUM(KDBUS_ITEM_ID_REMOVE),
+ ENUM(KDBUS_ITEM_REPLY_TIMEOUT),
+ ENUM(KDBUS_ITEM_REPLY_DEAD),
+};
+LOOKUP(MSG);
+const char *enum_PAYLOAD(long long id);
+TABLE(PAYLOAD) = {
+ ENUM(KDBUS_PAYLOAD_KERNEL),
+ ENUM(KDBUS_PAYLOAD_DBUS),
+};
+LOOKUP(PAYLOAD);
+
+static dbus_uint32_t
+get_next_client_serial (DBusTransportKdbus *transport)
+{
+ dbus_uint32_t serial;
+
+ serial = transport->client_serial++;
+
+ if (transport->client_serial == 0)
+ transport->client_serial = 1;
+
+ return serial;
+}
+
+/**
+ * Calculates length of the kdbus message content (payload).
+ *
+ * @param msg kdbus message
+ * @return the length of the kdbus message's payload.
+ */
+static int
+kdbus_message_size(const struct kdbus_msg* msg)
+{
+ const struct kdbus_item *item;
+ int ret_size = 0;
+
+ KDBUS_ITEM_FOREACH(item, msg, items)
+ {
+ if (item->size < KDBUS_ITEM_HEADER_SIZE)
+ {
+ _dbus_verbose(" +%s (%llu bytes) invalid data record\n", enum_MSG(item->type), item->size);
+ return -1;
+ }
+ switch (item->type)
+ {
+ case KDBUS_ITEM_PAYLOAD_OFF:
+ ret_size += item->vec.size;
+ break;
+ case KDBUS_ITEM_PAYLOAD_MEMFD:
+ ret_size += item->memfd.size;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return ret_size;
+}
+
+static int
+generate_NameSignal(const char *signal,
+ const char *name,
+ DBusTransportKdbus *transport)
+{
+ DBusMessage *message;
+
+ _dbus_verbose ("Generating %s for %s.\n", signal, name);
+
+ message = dbus_message_new_signal (DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, signal);
+ if (message == NULL)
+ return -1;
+
+ if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
+ goto error;
+ if (!dbus_message_set_destination (message, transport->my_DBus_unique_name))
+ goto error;
+ if (!dbus_message_set_sender(message, DBUS_SERVICE_DBUS))
+ goto error;
+ dbus_message_set_serial(message, get_next_client_serial(transport));
+
+ if (!add_message_to_received (message, transport->base.connection))
+ return -1;
+
+ return 0;
+
+ error:
+ dbus_message_unref (message);
+ return -1;
+}
+
+/*
+ * The NameOwnerChanged signals take three parameters with
+ * unique or well-known names, but only some forms actually
+ * exist:
+ *
+ * WELLKNOWN, "", UNIQUE → KDBUS_ITEM_NAME_ADD
+ * WELLKNOWN, UNIQUE, "" → KDBUS_ITEM_NAME_REMOVE
+ * WELLKNOWN, UNIQUE, UNIQUE → KDBUS_ITEM_NAME_CHANGE
+ * UNIQUE, "", UNIQUE → KDBUS_ITEM_ID_ADD
+ * UNIQUE, UNIQUE, "" → KDBUS_ITEM_ID_REMOVE
+ *
+ * For the latter two the two unique names must be identical.
+ */
+static int
+kdbus_handle_name_owner_changed(__u64 type,
+ const char *bus_name,
+ __u64 old,
+ __u64 new,
+ DBusTransportKdbus *transport)
+{
+ DBusMessage *message = NULL;
+ DBusMessageIter args;
+ char tmp_str[128];
+ const char *const_ptr;
+
+ if((message = dbus_message_new_signal(DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) == NULL)
+ return -1;
+
+ dbus_message_iter_init_append(message, &args);
+
+ // for ID_ADD and ID_REMOVE this function takes NULL as bus_name
+ if(bus_name == NULL)
+ {
+ sprintf(tmp_str,":1.%llu", old != 0 ? old : new);
+ const_ptr = tmp_str;
+ }
+ else
+ const_ptr = bus_name;
+
+ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &const_ptr))
+ goto error;
+
+ _dbus_verbose("%s\n", const_ptr);
+
+
+ if ((old==0) && (new==0))
+ {
+ /* kdbus generates its own set of events that can not be passed to
+ * client without translation. */
+ const char *src = "org.freedesktop.DBus";
+ const char *dst = "org.freedesktop.DBus";
+
+ if (type == KDBUS_ITEM_NAME_ADD || type == KDBUS_ITEM_ID_ADD)
+ src = "";
+ else if (type == KDBUS_ITEM_NAME_REMOVE || type == KDBUS_ITEM_ID_REMOVE)
+ dst = "";
+
+ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &src))
+ goto error;
+ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &dst))
+ goto error;
+
+ _dbus_verbose("[NameOwnerChanged:%s, old=%lld, new=%lld\n", __func__, old, new);
+ }
+ else
+ {
+ // determine and append old_id
+ if(old != 0)
+ {
+ sprintf(tmp_str,":1.%llu", old);
+ const_ptr = tmp_str;
+ }
+ else
+ const_ptr = "";
+
+ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &const_ptr))
+ goto error;
+
+ _dbus_verbose("%s\n", const_ptr);
+ // determine and append new_id
+ if(new != 0)
+ {
+ sprintf(tmp_str,":1.%llu", new);
+ const_ptr = tmp_str;
+ }
+ else
+ const_ptr = "";
+
+ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &const_ptr))
+ goto error;
+
+ _dbus_verbose("%s\n", const_ptr);
+ }
+
+ dbus_message_set_sender (message, DBUS_SERVICE_DBUS);
+ dbus_message_set_serial (message, get_next_client_serial (transport));
+
+ if (!add_message_to_received (message, transport->base.connection))
+ return -1;
+
+ return 0;
+
+error:
+ dbus_message_unref(message);
+
+ return -1;
+}
+
+static void
+_handle_item_timestamp (const struct kdbus_item *item)
+{
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ _dbus_verbose(" +%s (%llu bytes) realtime=%lluns monotonic=%lluns\n",
+ enum_MSG(item->type), item->size,
+ (unsigned long long)item->timestamp.realtime_ns,
+ (unsigned long long)item->timestamp.monotonic_ns);
+#endif
+}
+
+static void
+_handle_unexpected_item (const struct kdbus_item *item)
+{
+ _dbus_assert_not_reached ("unexpected item from kdbus");
+}
+
+static void
+_handle_padding (const struct kdbus_msg *msg,
+ const struct kdbus_item *end_of_items)
+{
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ if ((char *)end_of_items - ((char *)msg + msg->size) >= 8)
+ _dbus_verbose("invalid padding at end of message\n");
+#endif
+}
+
+static int
+kdbus_decode_dbus_message (const struct kdbus_msg *msg,
+ char *data,
+ DBusTransportKdbus *kdbus_transport,
+ int *fds,
+ int *n_fds)
+{
+ const struct kdbus_item *item;
+ int ret_size = 0;
+
+ *n_fds = 0;
+
+ KDBUS_ITEM_FOREACH(item, msg, items)
+ {
+ if (item->size < KDBUS_ITEM_HEADER_SIZE)
+ {
+ _dbus_verbose(" +%s (%llu bytes) invalid data record\n", enum_MSG(item->type), item->size);
+ ret_size = -1;
+ break;
+ }
+
+ switch (item->type)
+ {
+ case KDBUS_ITEM_PAYLOAD_OFF:
+ memcpy(data, (char *)msg+item->vec.offset, item->vec.size);
+ data += item->vec.size;
+ ret_size += item->vec.size;
+
+ if (-1 != debug)
+ {
+ debug_c_str ("Message part arrived:", (char *)msg+item->vec.offset, item->vec.size);
+ }
+
+ _dbus_verbose(" +%s (%llu bytes) off=%llu size=%llu\n",
+ enum_MSG(item->type), item->size,
+ (unsigned long long)item->vec.offset,
+ (unsigned long long)item->vec.size);
+ break;
+
+ case KDBUS_ITEM_PAYLOAD_MEMFD:
+ {
+ char *buf;
+ uint64_t size;
+
+ size = item->memfd.size;
+ _dbus_verbose("memfd.size : %llu\n", (unsigned long long)size);
+
+ buf = mmap(NULL, size, PROT_READ , MAP_SHARED, item->memfd.fd, 0);
+ if (buf == MAP_FAILED)
+ {
+ _dbus_verbose("mmap() fd=%i failed:%m", item->memfd.fd);
+ return -1;
+ }
+
+ memcpy(data, buf, size);
+ data += size;
+ ret_size += size;
+
+ munmap(buf, size);
+ close(item->memfd.fd);
+
+ _dbus_verbose(" +%s (%llu bytes) off=%llu size=%llu\n",
+ enum_MSG(item->type), item->size,
+ (unsigned long long)item->vec.offset,
+ (unsigned long long)item->vec.size);
+ }
+ break;
+
+ case KDBUS_ITEM_FDS:
+ {
+ int i;
+
+ *n_fds = (item->size - KDBUS_ITEM_HEADER_SIZE) / sizeof(int);
+ memcpy(fds, item->fds, *n_fds * sizeof(int));
+ for (i = 0; i < *n_fds; i++)
+ _dbus_fd_set_close_on_exec(fds[i]);
+ }
+ break;
+
+ case KDBUS_ITEM_CREDS:
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ _dbus_verbose(" +%s (%llu bytes) uid=%lld, gid=%lld, pid=%lld, tid=%lld, starttime=%lld\n",
+ enum_MSG(item->type), item->size,
+ item->creds.uid, item->creds.gid,
+ item->creds.pid, item->creds.tid,
+ item->creds.starttime);
+#endif
+ break;
+
+ case KDBUS_ITEM_PID_COMM:
+ case KDBUS_ITEM_TID_COMM:
+ case KDBUS_ITEM_EXE:
+ case KDBUS_ITEM_CGROUP:
+ case KDBUS_ITEM_SECLABEL:
+ case KDBUS_ITEM_DST_NAME:
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ _dbus_verbose(" +%s (%llu bytes) '%s' (%zu)\n",
+ enum_MSG(item->type), item->size, item->str, strlen(item->str));
+#endif
+ break;
+
+ case KDBUS_ITEM_CMDLINE:
+ case KDBUS_ITEM_NAME:
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ {
+ __u64 size = item->size - KDBUS_ITEM_HEADER_SIZE;
+ const char *str = item->str;
+ int count = 0;
+
+ _dbus_verbose(" +%s (%llu bytes) ", enum_MSG(item->type), item->size);
+ while (size)
+ {
+ _dbus_verbose("'%s' ", str);
+ size -= strlen(str) + 1;
+ str += strlen(str) + 1;
+ count++;
+ }
+
+ _dbus_verbose("(%d string%s)\n", count, (count == 1) ? "" : "s");
+ }
+#endif
+ break;
+
+ case KDBUS_ITEM_AUDIT:
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ _dbus_verbose(" +%s (%llu bytes) loginuid=%llu sessionid=%llu\n",
+ enum_MSG(item->type), item->size,
+ (unsigned long long)item->data64[0],
+ (unsigned long long)item->data64[1]);
+#endif
+ break;
+
+ case KDBUS_ITEM_CAPS:
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ {
+ int n;
+ const uint32_t *cap;
+ int i;
+
+ _dbus_verbose(" +%s (%llu bytes) len=%llu bytes)\n",
+ enum_MSG(item->type), item->size,
+ (unsigned long long)item->size - KDBUS_ITEM_HEADER_SIZE);
+
+ cap = item->data32;
+ n = (item->size - KDBUS_ITEM_HEADER_SIZE) / 4 / sizeof(uint32_t);
+
+ _dbus_verbose(" CapInh=");
+ for (i = 0; i < n; i++)
+ _dbus_verbose("%08x", cap[(0 * n) + (n - i - 1)]);
+
+ _dbus_verbose(" CapPrm=");
+ for (i = 0; i < n; i++)
+ _dbus_verbose("%08x", cap[(1 * n) + (n - i - 1)]);
+
+ _dbus_verbose(" CapEff=");
+ for (i = 0; i < n; i++)
+ _dbus_verbose("%08x", cap[(2 * n) + (n - i - 1)]);
+
+ _dbus_verbose(" CapInh=");
+ for (i = 0; i < n; i++)
+ _dbus_verbose("%08x", cap[(3 * n) + (n - i - 1)]);
+ _dbus_verbose("\n");
+ }
+#endif
+ break;
+
+ case KDBUS_ITEM_TIMESTAMP:
+ _handle_item_timestamp (item);
+ break;
+
+ case KDBUS_ITEM_BLOOM_FILTER:
+ /* no handling */
+ break;
+
+ default:
+ _handle_unexpected_item (item);
+ break;
+ }
+ }
+
+ _handle_padding (msg, item);
+
+ return ret_size;
+}
+
+static int
+kdbus_decode_kernel_message (const struct kdbus_msg *msg,
+ DBusTransportKdbus *kdbus_transport)
+{
+ const struct kdbus_item *item;
+ int ret_size = 0;
+
+ KDBUS_ITEM_FOREACH (item, msg, items)
+ {
+ if (item->size < KDBUS_ITEM_HEADER_SIZE)
+ {
+ _dbus_verbose(" +%s (%llu bytes) invalid data record\n", enum_MSG (item->type), item->size);
+ ret_size = -1;
+ break;
+ }
+
+ switch (item->type)
+ {
+ case KDBUS_ITEM_REPLY_TIMEOUT:
+ case KDBUS_ITEM_REPLY_DEAD:
+ {
+ DBusMessage *message = NULL;
+ _dbus_verbose(" +%s (%llu bytes) cookie=%llu\n",
+ enum_MSG (item->type), item->size, msg->cookie_reply);
+
+ message = _dbus_generate_local_error_message (msg->cookie_reply,
+ item->type == KDBUS_ITEM_REPLY_TIMEOUT ? DBUS_ERROR_NO_REPLY : DBUS_ERROR_NAME_HAS_NO_OWNER, NULL);
+ if(message == NULL)
+ {
+ ret_size = -1;
+ goto out;
+ }
+
+ dbus_message_set_serial (message, get_next_client_serial(kdbus_transport));
+
+ if (!add_message_to_received (message, kdbus_transport->base.connection))
+ ret_size = -1;
+ }
+ break;
+
+ case KDBUS_ITEM_NAME_ADD:
+ case KDBUS_ITEM_NAME_REMOVE:
+ case KDBUS_ITEM_NAME_CHANGE:
+ {
+ int local_ret;
+
+ _dbus_verbose (" +%s (%llu bytes) '%s', old id=%lld, new id=%lld, old flags=0x%llx, new flags=0x%llx\n",
+ enum_MSG(item->type), (unsigned long long) item->size,
+ item->name_change.name, item->name_change.old_id.id,
+ item->name_change.new_id.id, item->name_change.old_id.flags,
+ item->name_change.new_id.flags);
+
+ if(item->name_change.new_id.id == kdbus_transport->my_kdbus_id)
+ ret_size = generate_NameSignal ("NameAcquired", item->name_change.name, kdbus_transport);
+ else if(item->name_change.old_id.id == kdbus_transport->my_kdbus_id)
+ ret_size = generate_NameSignal ("NameLost", item->name_change.name, kdbus_transport);
+
+ if (ret_size == -1)
+ goto out;
+
+ if(item->name_change.new_id.flags & KDBUS_NAME_ACTIVATOR)
+ local_ret = kdbus_handle_name_owner_changed (item->type,
+ item->name_change.name,
+ item->name_change.old_id.id, 0,
+ kdbus_transport);
+ else if(item->name_change.old_id.flags & KDBUS_NAME_ACTIVATOR)
+ local_ret = kdbus_handle_name_owner_changed (item->type,
+ item->name_change.name, 0,
+ item->name_change.new_id.id,
+ kdbus_transport);
+ else
+ local_ret = kdbus_handle_name_owner_changed (item->type,
+ item->name_change.name,
+ item->name_change.old_id.id,
+ item->name_change.new_id.id,
+ kdbus_transport);
+ if (local_ret == -1)
+ goto out;
+
+ ret_size += local_ret;
+ }
+ break;
+
+ case KDBUS_ITEM_ID_ADD:
+ case KDBUS_ITEM_ID_REMOVE:
+ _dbus_verbose(" +%s (%llu bytes) id=%llu flags=%llu\n",
+ enum_MSG(item->type), (unsigned long long) item->size,
+ (unsigned long long) item->id_change.id,
+ (unsigned long long) item->id_change.flags);
+
+ if(item->id_change.flags & KDBUS_HELLO_ACTIVATOR)
+ ret_size = kdbus_handle_name_owner_changed (item->type, NULL, 0, 0,
+ kdbus_transport);
+ else
+ ret_size = kdbus_handle_name_owner_changed (item->type, NULL,
+ item->type == KDBUS_ITEM_ID_ADD ? 0 : item->id_change.id,
+ item->type == KDBUS_ITEM_ID_ADD ? item->id_change.id : 0,
+ kdbus_transport);
+
+ if (ret_size == -1)
+ goto out;
+ break;
+
+ case KDBUS_ITEM_TIMESTAMP:
+ _handle_item_timestamp (item);
+ break;
+
+ default:
+ _handle_unexpected_item (item);
+ break;
+ }
+ }
+
+ _handle_padding (msg, item);
+
+out:
+ return ret_size;
+}
+
+/**
+ * Decodes kdbus message in order to extract DBus message and puts it into received data buffer
+ * and file descriptor's buffer. Also captures kdbus error messages and kdbus kernel broadcasts
+ * and converts all of them into appropriate DBus messages.
+ *
+ * @param msg kdbus message
+ * @param data place to copy DBus message to
+ * @param kdbus_transport transport
+ * @param fds place to store file descriptors received
+ * @param n_fds place to store quantity of file descriptors received
+ * @return number of DBus message's bytes received or -1 on error
+ */
+static int
+kdbus_decode_msg(const struct kdbus_msg *msg,
+ char *data,
+ DBusTransportKdbus *kdbus_transport,
+ int *fds,
+ int *n_fds)
+{
+ int ret_size = 0;
+
+#if KDBUS_MSG_DECODE_DEBUG == 1
+ _dbus_verbose("MESSAGE: %s (%llu bytes) flags=0x%llx, %s → %s, cookie=%llu, timeout=%llu\n",
+ enum_PAYLOAD(msg->payload_type),
+ (unsigned long long) msg->size,
+ (unsigned long long) msg->flags,
+ msg_id(msg->src_id),
+ msg_id(msg->dst_id),
+ (unsigned long long) msg->cookie,
+ (unsigned long long) msg->timeout_ns);
+#endif
+
+ switch (msg->payload_type)
+ {
+ case KDBUS_PAYLOAD_DBUS:
+ ret_size = kdbus_decode_dbus_message (msg, data, kdbus_transport, fds, n_fds);
+ break;
+ case KDBUS_PAYLOAD_KERNEL:
+ ret_size = kdbus_decode_kernel_message (msg, kdbus_transport);
+ break;
+ default:
+ _dbus_assert_not_reached ("unexpected payload type from kdbus");
+ break;
+ }
+
+ return ret_size;
+}
+
+/**
+ * Reads message from kdbus and puts it into DBus buffers
+ *
+ * @param kdbus_transport transport
+ * @param buffer place to copy received message to
+ * @param fds place to store file descriptors received with the message
+ * @param n_fds place to store quantity of file descriptors received
+ * @return size of received message on success, -1 on error
+ */
+static int
+kdbus_read_message(DBusTransportKdbus *kdbus_transport,
+ DBusString *buffer,
+ int *fds,
+ int *n_fds)
+{
+ int ret_size, buf_size;
+ struct kdbus_cmd_recv recv = {};
+ struct kdbus_msg *msg;
+ char *data;
+ int start;
+
+ start = _dbus_string_get_length (buffer);
+
+ recv.size = sizeof(recv);
+
+ if(kdbus_transport->activator != NULL)
+ recv.flags |= KDBUS_RECV_PEEK;
+
+ again:
+ if (ioctl(kdbus_transport->fd, KDBUS_CMD_RECV, &recv) < 0)
+ {
+ if(errno == EINTR)
+ goto again;
+ _dbus_verbose("kdbus error receiving message: %d (%m)\n", errno);
+ _dbus_string_set_length (buffer, start);
+ return -1;
+ }
+
+ msg = (struct kdbus_msg *)((char*)kdbus_transport->kdbus_mmap_ptr + recv.msg.offset);
+
+ buf_size = kdbus_message_size(msg);
+ if (buf_size == -1)
+ {
+ _dbus_verbose("kdbus error - too short message: %d (%m)\n", errno);
+ return -1;
+ }
+
+ /* What is the maximum size of the locally generated message?
+ I just assume 2048 bytes */
+ buf_size = MAX(buf_size, 2048);
+
+ if (!_dbus_string_lengthen (buffer, buf_size))
+ {
+ errno = ENOMEM;
+ return -1;
+ }
+ data = _dbus_string_get_data_len (buffer, start, buf_size);
+
+ ret_size = kdbus_decode_msg(msg, data, kdbus_transport, fds, n_fds);
+
+ if(ret_size == -1) /* error */
+ {
+ _dbus_string_set_length (buffer, start);
+ return -1;
+ }
+ else if (buf_size != ret_size) /* case of locally generated message */
+ {
+ _dbus_string_set_length (buffer, start + ret_size);
+ }
+
+ _dbus_message_loader_set_unique_sender_id (kdbus_transport->base.loader, msg->src_id);
+
+ if(kdbus_transport->activator != NULL)
+ return ret_size;
+
+ if (!kdbus_command_free (&kdbus_transport->base, recv.msg.offset))
+ {
+ _dbus_verbose("kdbus error freeing message: %d (%m)\n", errno);
+ return -1;
+ }
+
+ return ret_size;
+}
+
+/**
+ * Copy-paste from socket transport. Only renames done.
+ */
+static void
+free_watches (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+
+ _dbus_verbose ("start\n");
+
+ if (kdbus_transport->read_watch)
+ {
+ if (transport->connection)
+ _dbus_connection_remove_watch_unlocked (transport->connection,
+ kdbus_transport->read_watch);
+ _dbus_watch_invalidate (kdbus_transport->read_watch);
+ _dbus_watch_unref (kdbus_transport->read_watch);
+ kdbus_transport->read_watch = NULL;
+ }
+
+ if (kdbus_transport->write_watch)
+ {
+ if (transport->connection)
+ _dbus_connection_remove_watch_unlocked (transport->connection,
+ kdbus_transport->write_watch);
+ _dbus_watch_invalidate (kdbus_transport->write_watch);
+ _dbus_watch_unref (kdbus_transport->write_watch);
+ kdbus_transport->write_watch = NULL;
+ }
+
+ _dbus_verbose ("end\n");
+}
+
+/**
+ * Copy-paste from socket transport. Only done needed renames and removed
+ * lines related to encoded messages.
+ */
+static void
+transport_finalize (DBusTransport *transport)
+{
+ _dbus_verbose ("\n");
+
+ free_watches (transport);
+
+ _dbus_transport_finalize_base (transport);
+
+ _dbus_assert (((DBusTransportKdbus*) transport)->read_watch == NULL);
+ _dbus_assert (((DBusTransportKdbus*) transport)->write_watch == NULL);
+
+ free_matchmaker(((DBusTransportKdbus*) transport)->matchmaker);
+
+ free(((DBusTransportKdbus*) transport)->daemon_unique_name);
+
+ dbus_free (((DBusTransportKdbus*) transport)->activator);
+ dbus_free (transport);
+}
+
+/**
+ * Copy-paste from socket transport. Removed code related to authentication,
+ * socket_transport replaced by kdbus_transport.
+ */
+static void
+check_write_watch (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+ dbus_bool_t needed;
+
+ if (transport->connection == NULL)
+ return;
+
+ if (transport->disconnected)
+ {
+ _dbus_assert (kdbus_transport->write_watch == NULL);
+ return;
+ }
+
+ _dbus_transport_ref (transport);
+
+ needed = _dbus_connection_has_messages_to_send_unlocked (transport->connection);
+
+ _dbus_verbose ("check_write_watch(): needed = %d on connection %p watch %p fd = %d outgoing messages exist %d\n",
+ needed, transport->connection, kdbus_transport->write_watch,
+ kdbus_transport->fd,
+ _dbus_connection_has_messages_to_send_unlocked (transport->connection));
+
+ _dbus_connection_toggle_watch_unlocked (transport->connection,
+ kdbus_transport->write_watch,
+ needed);
+
+ _dbus_transport_unref (transport);
+}
+
+/**
+ * Copy-paste from socket transport. Removed code related to authentication,
+ * socket_transport replaced by kdbus_transport.
+ */
+static void
+check_read_watch (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+ dbus_bool_t need_read_watch;
+
+ _dbus_verbose ("fd = %d\n",kdbus_transport->fd);
+
+ if (transport->connection == NULL)
+ return;
+
+ if (transport->disconnected)
+ {
+ _dbus_assert (kdbus_transport->read_watch == NULL);
+ return;
+ }
+
+ _dbus_transport_ref (transport);
+
+ need_read_watch =
+ (_dbus_counter_get_size_value (transport->live_messages) < transport->max_live_messages_size) &&
+ (_dbus_counter_get_unix_fd_value (transport->live_messages) < transport->max_live_messages_unix_fds);
+
+ _dbus_verbose (" setting read watch enabled = %d\n", need_read_watch);
+
+ _dbus_connection_toggle_watch_unlocked (transport->connection,
+ kdbus_transport->read_watch,
+ need_read_watch);
+
+ _dbus_transport_unref (transport);
+}
+
+/**
+ * Copy-paste from socket transport.
+ */
+static void
+do_io_error (DBusTransport *transport)
+{
+ _dbus_transport_ref (transport);
+ _dbus_transport_disconnect (transport);
+ _dbus_transport_unref (transport);
+}
+
+/**
+ * Based on do_writing from socket transport.
+ * Removed authentication code and code related to encoded messages
+ * and adapted to kdbus transport.
+ * In socket transport returns false on out-of-memory. Here this won't happen,
+ * so it always returns TRUE.
+ */
+static dbus_bool_t
+do_writing (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+ int total = 0;
+ dbus_bool_t oom = FALSE;
+
+ if (transport->disconnected)
+ {
+ _dbus_verbose ("Not connected, not writing anything\n");
+ return TRUE;
+ }
+
+ _dbus_verbose ("do_writing(), have_messages = %d, fd = %d\n",
+ _dbus_connection_has_messages_to_send_unlocked (transport->connection), kdbus_transport->fd);
+
+ while (!transport->disconnected && _dbus_connection_has_messages_to_send_unlocked (transport->connection))
+ {
+ int bytes_written;
+ DBusMessage *message;
+ const DBusString *header;
+ const DBusString *body;
+ const char* pDestination;
+
+ if (total > kdbus_transport->max_bytes_written_per_iteration)
+ {
+ _dbus_verbose ("%d bytes exceeds %d bytes written per iteration, returning\n",
+ total, kdbus_transport->max_bytes_written_per_iteration);
+ goto out;
+ }
+
+ message = _dbus_connection_get_message_to_send (transport->connection);
+ _dbus_assert (message != NULL);
+ pDestination = dbus_message_get_destination(message);
+
+ if(pDestination)
+ {
+ int ret;
+
+ ret = capture_org_freedesktop_DBus((DBusTransportKdbus*)transport, pDestination, message);
+ if(ret < 0) //error
+ {
+ bytes_written = -1;
+ goto written;
+ }
+ else if(ret == 0) //hello message captured and handled correctly
+ {
+ _dbus_message_get_network_data (message, &header, &body);
+ bytes_written = _dbus_string_get_length(header) + _dbus_string_get_length(body);
+ goto written;
+ }
+ //else send as regular message
+ }
+
+ bytes_written = kdbus_write_msg(kdbus_transport, message, pDestination);
+
+ written:
+ if (bytes_written < 0)
+ {
+ if(errno == ENOMEM)
+ {
+ oom = TRUE;
+ goto out;
+ }
+
+ /* EINTR already handled for us */
+
+ /* For some discussion of why we also ignore EPIPE here, see
+ * http://lists.freedesktop.org/archives/dbus/2008-March/009526.html
+ */
+
+ if (_dbus_get_is_errno_eagain_or_ewouldblock () || _dbus_get_is_errno_epipe ())
+ goto out;
+ else
+ {
+ _dbus_verbose ("Error writing to remote app: %s\n", _dbus_strerror_from_errno ());
+// do_io_error (transport);
+ /*TODO the comment above may cause side effects, but must be removed here
+ to not disconnect the connection. If side-effects appears, reporting errors for upper functions
+ must be rearranged.*/
+ goto out;
+ }
+ }
+ else
+ {
+ int total_bytes_to_write;
+
+ _dbus_message_get_network_data (message, &header, &body);
+ total_bytes_to_write = _dbus_string_get_length(header)
+ + _dbus_string_get_length(body);
+ _dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
+ total_bytes_to_write);
+
+ total += bytes_written;
+
+ _dbus_assert (bytes_written == total_bytes_to_write);
+
+ _dbus_connection_message_sent_unlocked (transport->connection,
+ message);
+ }
+ }
+
+out:
+ if (oom)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+/**
+ * Based on do_reading from socket transport.
+ * Removed authentication code and code related to encoded messages
+ * and adapted to kdbus transport.
+ * returns false on out-of-memory
+ */
+static dbus_bool_t
+do_reading (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+ DBusString *buffer;
+ int bytes_read;
+ dbus_bool_t oom = FALSE;
+ int *fds, n_fds;
+ int total = 0;
+
+ _dbus_verbose ("fd = %d\n",kdbus_transport->fd);
+
+ again:
+
+ /* See if we've exceeded max messages and need to disable reading */
+ if(kdbus_transport->activator == NULL)
+ check_read_watch (transport);
+
+ if (total > kdbus_transport->max_bytes_read_per_iteration)
+ {
+ _dbus_verbose ("%d bytes exceeds %d bytes read per iteration, returning\n",
+ total, kdbus_transport->max_bytes_read_per_iteration);
+ goto out;
+ }
+
+ _dbus_assert (kdbus_transport->read_watch != NULL ||
+ transport->disconnected);
+
+ if (transport->disconnected)
+ goto out;
+
+ if (!dbus_watch_get_enabled (kdbus_transport->read_watch))
+ return TRUE;
+
+ if (!_dbus_message_loader_get_unix_fds(transport->loader, &fds, &n_fds))
+ {
+ _dbus_verbose ("Out of memory reading file descriptors\n");
+ oom = TRUE;
+ goto out;
+ }
+ _dbus_message_loader_get_buffer (transport->loader, &buffer);
+
+ bytes_read = kdbus_read_message(kdbus_transport, buffer, fds, &n_fds);
+
+ if (bytes_read >= 0 && n_fds > 0)
+ _dbus_verbose("Read %i unix fds\n", n_fds);
+
+ _dbus_message_loader_return_buffer (transport->loader,
+ buffer);
+ _dbus_message_loader_return_unix_fds(transport->loader, fds, bytes_read < 0 ? 0 : n_fds);
+
+ if (bytes_read < 0)
+ {
+ /* EINTR already handled for us */
+
+ if (_dbus_get_is_errno_enomem ())
+ {
+ _dbus_verbose ("Out of memory in read()/do_reading()\n");
+ oom = TRUE;
+ goto out;
+ }
+ else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
+ goto out;
+ else
+ {
+ _dbus_verbose ("Error reading from remote app: %s\n",
+ _dbus_strerror_from_errno ());
+ do_io_error (transport);
+ goto out;
+ }
+ }
+ else if (bytes_read > 0)
+ {
+ _dbus_verbose (" read %d bytes\n", bytes_read);
+
+ total += bytes_read;
+
+ if (!_dbus_transport_queue_messages (transport))
+ {
+ oom = TRUE;
+ _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
+ goto out;
+ }
+
+ /* Try reading more data until we get EAGAIN and return, or
+ * exceed max bytes per iteration. If in blocking mode of
+ * course we'll block instead of returning.
+ */
+ goto again;
+ }
+ /* 0 == bytes_read is for kernel messages */
+
+ out:
+ if (oom)
+ return FALSE;
+ return TRUE;
+}
+
+/**
+ * Copy-paste from socket transport, with socket replaced by kdbus.
+ */
+static dbus_bool_t
+unix_error_with_read_to_come (DBusTransport *itransport,
+ DBusWatch *watch,
+ unsigned int flags)
+{
+ DBusTransportKdbus *transport = (DBusTransportKdbus *) itransport;
+
+ if (!((flags & DBUS_WATCH_HANGUP) || (flags & DBUS_WATCH_ERROR)))
+ return FALSE;
+
+ /* If we have a read watch enabled ...
+ we -might have data incoming ... => handle the HANGUP there */
+ if (watch != transport->read_watch && _dbus_watch_get_enabled (transport->read_watch))
+ return FALSE;
+
+ return TRUE;
+}
+
+/**
+ * Copy-paste from socket transport. Removed authentication related code
+ * and renamed socket_transport to kdbus_transport.
+ */
+static dbus_bool_t
+kdbus_handle_watch (DBusTransport *transport,
+ DBusWatch *watch,
+ unsigned int flags)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+
+ _dbus_assert (watch == kdbus_transport->read_watch ||
+ watch == kdbus_transport->write_watch);
+ _dbus_assert (watch != NULL);
+
+ /* If we hit an error here on a write watch, don't disconnect the transport yet because data can
+ * still be in the buffer and do_reading may need several iteration to read
+ * it all (because of its max_bytes_read_per_iteration limit).
+ */
+ if (!(flags & DBUS_WATCH_READABLE) && unix_error_with_read_to_come (transport, watch, flags))
+ {
+ _dbus_verbose ("Hang up or error on watch\n");
+ _dbus_transport_disconnect (transport);
+ return TRUE;
+ }
+
+ if (watch == kdbus_transport->read_watch &&
+ (flags & DBUS_WATCH_READABLE))
+ {
+ _dbus_verbose ("handling read watch %p flags = %x\n",
+ watch, flags);
+
+ if (!do_reading (transport))
+ {
+ _dbus_verbose ("no memory to read\n");
+ return FALSE;
+ }
+ }
+ else if (watch == kdbus_transport->write_watch &&
+ (flags & DBUS_WATCH_WRITABLE))
+ {
+ _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
+ _dbus_connection_has_messages_to_send_unlocked (transport->connection));
+
+ if (!do_writing (transport))
+ {
+ _dbus_verbose ("no memory to write\n");
+ return FALSE;
+ }
+
+ /* See if we still need the write watch */
+ check_write_watch (transport);
+ }
+
+ return TRUE;
+}
+
+/**
+ * Copy-paste from socket transport, but socket_transport renamed to kdbus_transport
+ * and _dbus_close_socket replaced with close().
+ */
+static void
+kdbus_disconnect (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+
+ _dbus_verbose ("\n");
+
+ free_watches (transport);
+
+ again:
+ if (close (kdbus_transport->fd) < 0)
+ {
+ if (errno == EINTR)
+ goto again;
+ }
+ kdbus_transport->fd = -1;
+
+ if(kdbus_transport->kdbus_mmap_ptr == NULL) {
+ printf("libdbus:kdbus_transport->kdbus_mmap_ptr is NULL\n");
+ return;
+ }
+
+ if(munmap (kdbus_transport->kdbus_mmap_ptr, kdbus_transport->receive_pool_size) == -1)
+ _dbus_verbose ("munmap when disconnecting failed: %d, %m", errno);
+ kdbus_transport->kdbus_mmap_ptr = NULL;
+}
+
+/**
+ * Copy-paste from socket transport. Renamed socket_transport to
+ * kdbus_transport and added setting authenticated to TRUE, because
+ * we do not perform authentication in kdbus, so we have mark is as already done
+ * to make everything work.
+ */
+static dbus_bool_t
+kdbus_connection_set (DBusTransport *transport)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+
+ /* FIXME create accessor function for this one */
+ transport->authenticated = TRUE;
+
+ _dbus_watch_set_handler (kdbus_transport->write_watch,
+ _dbus_connection_handle_watch,
+ transport->connection, NULL);
+
+ _dbus_watch_set_handler (kdbus_transport->read_watch,
+ _dbus_connection_handle_watch,
+ transport->connection, NULL);
+
+ if (!_dbus_connection_add_watch_unlocked (transport->connection,
+ kdbus_transport->write_watch))
+ return FALSE;
+
+ if (!_dbus_connection_add_watch_unlocked (transport->connection,
+ kdbus_transport->read_watch))
+ {
+ _dbus_connection_remove_watch_unlocked (transport->connection,
+ kdbus_transport->write_watch);
+ return FALSE;
+ }
+
+ check_read_watch (transport);
+ check_write_watch (transport);
+
+ return TRUE;
+}
+
+/**
+ * Copy-paste from socket_transport.
+ * Socket_transport renamed to kdbus_transport
+ *
+ * Original dbus copy-pasted @todo comment below.
+ * @todo We need to have a way to wake up the select sleep if
+ * a new iteration request comes in with a flag (read/write) that
+ * we're not currently serving. Otherwise a call that just reads
+ * could block a write call forever (if there are no incoming
+ * messages).
+ */
+static void
+kdbus_do_iteration (DBusTransport *transport,
+ unsigned int flags,
+ int timeout_milliseconds)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+ DBusPollFD poll_fd;
+ int poll_res;
+ int poll_timeout;
+
+ _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
+ flags & DBUS_ITERATION_DO_READING ? "read" : "",
+ flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
+ timeout_milliseconds,
+ kdbus_transport->read_watch,
+ kdbus_transport->write_watch,
+ kdbus_transport->fd);
+
+ poll_fd.fd = kdbus_transport->fd;
+ poll_fd.events = 0;
+
+ /*
+ * TODO test this.
+ * This fix is for reply_with_error function.
+ * When timeout is set to -1 in client application,
+ * error messages are inserted directly to incoming queue and
+ * application hangs on dbus_poll.
+ */
+ if(_dbus_connection_get_n_incoming(transport->connection) > 0)
+ {
+ timeout_milliseconds = 0;
+ }
+ /* This is kind of a hack; if we have stuff to write, then try
+ * to avoid the poll. This is probably about a 5% speedup on an
+ * echo client/server.
+ *
+ * If both reading and writing were requested, we want to avoid this
+ * since it could have funky effects:
+ * - both ends spinning waiting for the other one to read
+ * data so they can finish writing
+ * - prioritizing all writing ahead of reading
+ */
+ if ((flags & DBUS_ITERATION_DO_WRITING) &&
+ !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
+ !transport->disconnected &&
+ _dbus_connection_has_messages_to_send_unlocked (transport->connection))
+ {
+ do_writing (transport);
+
+ if (transport->disconnected ||
+ !_dbus_connection_has_messages_to_send_unlocked (transport->connection))
+ goto out;
+ }
+
+ /* If we get here, we decided to do the poll() after all */
+ _dbus_assert (kdbus_transport->read_watch);
+ if (flags & DBUS_ITERATION_DO_READING)
+ poll_fd.events |= _DBUS_POLLIN;
+
+ _dbus_assert (kdbus_transport->write_watch);
+ if (flags & DBUS_ITERATION_DO_WRITING)
+ poll_fd.events |= _DBUS_POLLOUT;
+
+ if (poll_fd.events)
+ {
+ if ( (flags & DBUS_ITERATION_BLOCK) && !(flags & DBUS_ITERATION_DO_WRITING))
+ poll_timeout = timeout_milliseconds;
+ else
+ poll_timeout = 0;
+
+ /* For blocking selects we drop the connection lock here
+ * to avoid blocking out connection access during a potentially
+ * indefinite blocking call. The io path is still protected
+ * by the io_path_cond condvar, so we won't reenter this.
+ */
+ if (flags & DBUS_ITERATION_BLOCK)
+ {
+ _dbus_verbose ("unlock pre poll\n");
+ _dbus_connection_unlock (transport->connection);
+ }
+
+ again:
+ poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
+
+ if (poll_res < 0 && _dbus_get_is_errno_eintr ())
+ goto again;
+
+ if (flags & DBUS_ITERATION_BLOCK)
+ {
+ _dbus_verbose ("lock post poll\n");
+ _dbus_connection_lock (transport->connection);
+ }
+
+ if (poll_res >= 0)
+ {
+ if (poll_res == 0)
+ poll_fd.revents = 0; /* some concern that posix does not guarantee this;
+ * valgrind flags it as an error. though it probably
+ * is guaranteed on linux at least.
+ */
+
+ if (poll_fd.revents & _DBUS_POLLERR)
+ do_io_error (transport);
+ else
+ {
+ dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
+
+ _dbus_verbose ("in iteration, need_read=%d\n",
+ need_read);
+
+ if (need_read && (flags & DBUS_ITERATION_DO_READING))
+ do_reading (transport);
+ /* We always be able to write to kdbus */
+ if (flags & DBUS_ITERATION_DO_WRITING)
+ do_writing (transport);
+ }
+ }
+ else
+ _dbus_verbose ("Error from _dbus_poll(): %s\n", _dbus_strerror_from_errno ());
+ }
+
+ out:
+ /* We need to install the write watch only if we did not
+ * successfully write everything. Note we need to be careful that we
+ * don't call check_write_watch *before* do_writing, since it's
+ * inefficient to add the write watch, and we can avoid it most of
+ * the time since we can write immediately.
+ *
+ * However, we MUST always call check_write_watch(); DBusConnection code
+ * relies on the fact that running an iteration will notice that
+ * messages are pending.
+ */
+ check_write_watch (transport);
+
+ _dbus_verbose (" ... leaving do_iteration()\n");
+}
+
+/**
+ * Copy-paste from socket transport.
+ */
+static void
+kdbus_live_messages_changed (DBusTransport *transport)
+{
+ /* See if we should look for incoming messages again */
+ check_read_watch (transport);
+}
+
+/**
+ * Gets file descriptor of the kdbus bus.
+ * @param transport transport
+ * @param fd_p place to write fd to
+ * @returns always TRUE
+ */
+static dbus_bool_t
+kdbus_get_kdbus_fd (DBusTransport *transport,
+ int *fd_p)
+{
+ DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus*) transport;
+
+ *fd_p = kdbus_transport->fd;
+
+ return TRUE;
+}
+
+static const DBusTransportVTable kdbus_vtable = {
+ transport_finalize,
+ kdbus_handle_watch,
+ kdbus_disconnect,
+ kdbus_connection_set,
+ kdbus_do_iteration,
+ kdbus_live_messages_changed,
+ kdbus_get_kdbus_fd
+};
+
+/**
+ * Copy-paste from dbus_transport_socket with needed changes.
+ *
+ * Creates a new transport for the given kdbus file descriptor and address.
+ * The file descriptor must be nonblocking.
+ *
+ * @param fd the file descriptor.
+ * @param address the transport's address
+ * @returns the new transport, or #NULL if no memory.
+ */
+static DBusTransport*
+new_kdbus_transport (int fd,
+ const DBusString *address,
+ const char *activator)
+{
+ DBusTransportKdbus *kdbus_transport;
+
+ kdbus_transport = dbus_new0 (DBusTransportKdbus, 1);
+ if (kdbus_transport == NULL)
+ return NULL;
+
+ kdbus_transport->write_watch = _dbus_watch_new (fd,
+ DBUS_WATCH_WRITABLE,
+ FALSE,
+ NULL, NULL, NULL);
+ if (kdbus_transport->write_watch == NULL)
+ goto failed_2;
+
+ kdbus_transport->read_watch = _dbus_watch_new (fd,
+ DBUS_WATCH_READABLE,
+ FALSE,
+ NULL, NULL, NULL);
+ if (kdbus_transport->read_watch == NULL)
+ goto failed_3;
+
+ if (!_dbus_transport_init_base (&kdbus_transport->base,
+ &kdbus_vtable,
+ NULL, address))
+ goto failed_4;
+
+ kdbus_transport->fd = fd;
+
+ /* These values should probably be tunable or something. */
+ kdbus_transport->max_bytes_read_per_iteration = MAX_BYTES_PER_ITERATION;
+ kdbus_transport->max_bytes_written_per_iteration = MAX_BYTES_PER_ITERATION;
+
+ kdbus_transport->kdbus_mmap_ptr = NULL;
+
+ if(activator!=NULL)
+ {
+ int size = strlen(activator);
+ if(size)
+ {
+ kdbus_transport->activator = dbus_new(char, size + 1 );
+ if(kdbus_transport->activator != NULL)
+ strcpy(kdbus_transport->activator, activator);
+ else
+ goto failed_2;
+ }
+ }
+ else
+ kdbus_transport->activator = NULL;
+
+ kdbus_transport->matchmaker = matchmaker_new();
+
+ kdbus_transport->daemon_unique_name = NULL;
+ kdbus_transport->client_serial = 1;
+ kdbus_transport->my_kdbus_id = 0;
+
+ return (DBusTransport*) kdbus_transport;
+
+ failed_4:
+ _dbus_watch_invalidate (kdbus_transport->read_watch);
+ _dbus_watch_unref (kdbus_transport->read_watch);
+ failed_3:
+ _dbus_watch_invalidate (kdbus_transport->write_watch);
+ _dbus_watch_unref (kdbus_transport->write_watch);
+ failed_2:
+ dbus_free (kdbus_transport);
+ return NULL;
+}
+
+/**
+ * Opens a connection to the kdbus bus
+ *
+ * @param path the path to kdbus bus
+ * @param error return location for error code
+ * @returns connection file descriptor or -1 on error
+ */
+static int
+_dbus_connect_kdbus (const char *path,
+ DBusError *error)
+{
+ int fd;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ _dbus_verbose ("connecting to kdbus bus %s\n", path);
+
+ fd = open(path, O_RDWR|O_CLOEXEC|O_NONBLOCK);
+ if (fd < 0)
+ dbus_set_error(error, _dbus_error_from_errno (errno), "Failed to open file descriptor: %s", _dbus_strerror (errno));
+
+ return fd;
+}
+
+/**
+ * Connects to kdbus, creates and sets-up transport.
+ *
+ * @param path the path to the bus.
+ * @param error address where an error can be returned.
+ * @returns a new transport, or #NULL on failure.
+ */
+static DBusTransport*
+_dbus_transport_new_for_kdbus (const char *path,
+ const char *activator,
+ DBusError *error)
+{
+ int fd;
+ DBusTransport *transport;
+ DBusString address;
+ const char *dbgenv = getenv("G_DBUS_DEBUG");
+ if (dbgenv != NULL)
+ {
+ if (!strcmp(dbgenv, "message"))
+ debug = 1;
+ else if (!strcmp(dbgenv, "all"))
+ debug = 2;
+ }
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ if (!_dbus_string_init (&address))
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ return NULL;
+ }
+
+ fd = -1;
+
+ if ((!_dbus_string_append (&address, DBUS_ADDRESS_KDBUS "path=")) || (!_dbus_string_append (&address, path)))
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ goto failed_0;
+ }
+
+ fd = _dbus_connect_kdbus (path, error);
+ if (fd < 0)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ goto failed_0;
+ }
+
+ _dbus_verbose ("Successfully connected to kdbus bus %s\n", path);
+
+ transport = new_kdbus_transport (fd, &address, activator);
+ if (transport == NULL)
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ goto failed_1;
+ }
+
+ _dbus_string_free (&address);
+
+ return transport;
+
+ failed_1:
+ again:
+ if (close (fd) < 0)
+ {
+ if (errno == EINTR)
+ goto again;
+ }
+ failed_0:
+ _dbus_string_free (&address);
+ return NULL;
+}
+
+
+/**
+ * Opens kdbus transport if method from address entry is kdbus
+ *
+ * @param entry the address entry to open
+ * @param transport_p return location for the opened transport
+ * @param error place to store error
+ * @returns result of the attempt as a DBusTransportOpenResult enum
+ */
+DBusTransportOpenResult
+_dbus_transport_open_kdbus(DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error)
+{
+ const char *method;
+
+ method = dbus_address_entry_get_method (entry);
+ _dbus_assert (method != NULL);
+
+ if (strcmp (method, "kernel") == 0)
+ {
+ const char *path = dbus_address_entry_get_value (entry, "path");
+ const char *activator = dbus_address_entry_get_value (entry, "activator");
+
+ if (path == NULL)
+ {
+ _dbus_set_bad_address (error, "kdbus", "path", NULL);
+ return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
+ }
+
+ *transport_p = _dbus_transport_new_for_kdbus (path, activator, error);
+
+ if (*transport_p == NULL)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_OK;
+ }
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
+ }
+}
+
+DBusWatch*
+dbus_transport_get_read_watch(DBusTransport *transport)
+{
+ return ((DBusTransportKdbus*)transport)->read_watch;
+}
+
+char*
+dbus_transport_get_activator_name(DBusTransport *transport)
+{
+ return ((DBusTransportKdbus*)transport)->activator;
+}
+
+/** @} */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-transport-kdbus.h kdbus subclasses of DBusTransport
+ *
+ * Copyright (C) 2002, 2006 Red Hat Inc.
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#ifndef DBUS_TRANSPORT_KDBUS_H_
+#define DBUS_TRANSPORT_KDBUS_H_
+
+#include "../config.h"
+#include "dbus-transport-protected.h"
+#include <linux/types.h>
+
+#define REGISTER_FLAG_MONITOR 1 << 0
+
+__u64 dbus_transport_get_bloom_size(DBusTransport* transport);
+__u64 dbus_transport_get_bloom_n_hash(DBusTransport* transport);
+void* dbus_transport_get_pool_pointer(DBusTransport* transport);
+DBusTransportOpenResult _dbus_transport_open_kdbus(DBusAddressEntry *entry, DBusTransport **transport_p, DBusError *error);
+DBusWatch * dbus_transport_get_read_watch(DBusTransport* transport);
+char* dbus_transport_get_activator_name(DBusTransport *transport);
+
+#endif
/* dbus-transport.c DBusTransport object (internal to D-Bus implementation)
*
* Copyright (C) 2002, 2003 Red Hat Inc.
+ * Copyright (C) 2013 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
#include "dbus-credentials.h"
#include "dbus-mainloop.h"
#include "dbus-message.h"
+#include "dbus-transport-kdbus.h"
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
#include "dbus-server-debug-pipe.h"
#endif
DBusMessageLoader *loader;
DBusAuth *auth;
DBusCounter *counter;
- char *address_copy;
+ char *address_copy = NULL;
DBusCredentials *creds;
loader = _dbus_message_loader_new ();
if (server_guid)
auth = _dbus_auth_server_new (server_guid);
else
- auth = _dbus_auth_client_new ();
+ {
+ _dbus_assert (address != NULL);
+ if (!_dbus_string_copy_data (address, &address_copy))
+ {
+ _dbus_message_loader_unref (loader);
+ return FALSE;
+ }
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(address_copy == strstr(address_copy, DBUS_ADDRESS_KDBUS "path=")) //FIXME -> path doesn't have to be first key in address
+ auth = _dbus_auth_client_new_kdbus();
+ else
+#endif
+ auth = _dbus_auth_client_new ();
+ }
+
if (auth == NULL)
{
_dbus_message_loader_unref (loader);
+
+ if (address_copy != NULL)
+ dbus_free(address_copy);
+
return FALSE;
}
{
_dbus_auth_unref (auth);
_dbus_message_loader_unref (loader);
+
+ if (address_copy != NULL)
+ dbus_free(address_copy);
+
return FALSE;
}
_dbus_counter_unref (counter);
_dbus_auth_unref (auth);
_dbus_message_loader_unref (loader);
+
+ if (address_copy != NULL)
+ dbus_free(address_copy);
+
return FALSE;
}
_dbus_assert (address == NULL);
address_copy = NULL;
}
- else
- {
- _dbus_assert (address != NULL);
-
- if (!_dbus_string_copy_data (address, &address_copy))
- {
- _dbus_credentials_unref (creds);
- _dbus_counter_unref (counter);
- _dbus_auth_unref (auth);
- _dbus_message_loader_unref (loader);
- return FALSE;
- }
- }
transport->refcount = 1;
transport->vtable = vtable;
DBusTransport **transport_p,
DBusError *error);
} open_funcs[] = {
+#ifdef ENABLE_KDBUS_TRANSPORT
+ { _dbus_transport_open_kdbus },
+#endif
{ _dbus_transport_open_socket },
{ _dbus_transport_open_platform_specific },
{ _dbus_transport_open_autolaunch }
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* kdbus-common.c kdbus related utils for daemon and libdbus
+ *
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version and under the terms of the GNU
+ * Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#include "kdbus.h"
+#include "kdbus-common.h"
+#include "dbus-transport-kdbus.h"
+#include <string.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <dbus/dbus-internals.h>
+#include <dbus/dbus-shared.h>
+#include "dbus-signals.h"
+#include <stdio.h>
+#include <sys/ioctl.h>
+
+/*
+ * Converts string with unique name into __u64 id number. If the name is not unique, sets error.
+ */
+__u64
+sender_name_to_id(const char *name,
+ DBusError *error)
+{
+ __u64 sender_id = 0;
+
+ if(!strncmp(name, ":1.", 3)) /*if name is unique name it must be converted to unique id*/
+ sender_id = strtoull(&name[3], NULL, 10);
+ else
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, "Could not convert sender of the message into kdbus unique id");
+
+ return sender_id;
+}
+
+static void make_item_name(const char *name, struct kdbus_item *item)
+{
+ size_t len = strlen(name) + 1;
+ item->size = KDBUS_ITEM_HEADER_SIZE + len;
+ item->type = KDBUS_ITEM_NAME;
+
+ memcpy(item->str, name, len);
+}
+
+/**
+ *
+ * Asks the bus to assign the given name to the connection.
+ *
+ * Use same flags as original dbus version with one exception below.
+ * Result flag #DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER is currently
+ * never returned by kdbus, instead DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
+ * is returned by kdbus.
+ *
+ * @param transport transport of the connection
+ * @param name the name to request
+ * @param flags flags
+ * @returns a DBus result code on success, -errno on error
+ */
+int
+request_kdbus_name(DBusTransport *transport,
+ const char *name,
+ const __u64 flags)
+{
+ struct kdbus_cmd *cmd_name;
+ int fd;
+ size_t len = strlen(name) + 1;
+
+ __u64 size = sizeof(*cmd_name) + KDBUS_ITEM_SIZE(len);
+ __u64 flags_kdbus = 0;
+
+ if(!_dbus_transport_get_socket_fd (transport, &fd))
+ return FALSE;
+
+ cmd_name = alloca(size);
+ cmd_name->size = size;
+
+ if(flags & DBUS_NAME_FLAG_ALLOW_REPLACEMENT)
+ flags_kdbus |= KDBUS_NAME_ALLOW_REPLACEMENT;
+ if(!(flags & DBUS_NAME_FLAG_DO_NOT_QUEUE))
+ flags_kdbus |= KDBUS_NAME_QUEUE;
+ if(flags & DBUS_NAME_FLAG_REPLACE_EXISTING)
+ flags_kdbus |= KDBUS_NAME_REPLACE_EXISTING;
+
+ cmd_name->flags = flags_kdbus;
+ make_item_name(name, &(cmd_name->items[0]));
+
+ _dbus_verbose("Request name - flags sent: 0x%llx !!!!!!!!!\n", cmd_name->flags);
+
+ if (ioctl(fd, KDBUS_CMD_NAME_ACQUIRE, cmd_name) < 0)
+ {
+ _dbus_verbose ("error acquiring name '%s': %m, %d\n", name, errno);
+ if(errno == EEXIST)
+ return DBUS_REQUEST_NAME_REPLY_EXISTS;
+ if(errno == EALREADY)
+ return DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER;
+ return -errno;
+ }
+ else if ((cmd_name->return_flags & KDBUS_NAME_PRIMARY)
+ && !(cmd_name->return_flags & KDBUS_NAME_ACQUIRED))
+ return DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER;
+
+ _dbus_verbose("Request name - received flag: 0x%llx !!!!!!!!!\n", cmd_name->flags);
+
+ if(cmd_name->return_flags & KDBUS_NAME_IN_QUEUE)
+ return DBUS_REQUEST_NAME_REPLY_IN_QUEUE;
+
+ return DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
+}
+
+/**
+ *
+ * Releases well-known name - the connections resign from the name
+ * which can be then assigned to another connection or the connection
+ * is being removed from the queue for that name
+ *
+ * @param fd - file descriptor of the connection
+ * @param name the name to request
+ * @param id unique id of the connection for which the name is being released
+ * @returns a DBus result code on success, -errno on error
+ */
+int
+release_kdbus_name(DBusTransport *transport,
+ const char *name)
+{
+ struct kdbus_cmd *cmd_name;
+ int fd;
+
+ size_t len = strlen(name)+1;
+ __u64 size = sizeof(*cmd_name) + KDBUS_ITEM_SIZE(len);
+
+ if(!_dbus_transport_get_socket_fd (transport, &fd))
+ return FALSE;
+
+ cmd_name = alloca(size);
+ cmd_name->size = size;
+ cmd_name->flags = 0;
+ make_item_name(name, &(cmd_name->items[0]));
+
+ if (ioctl(fd, KDBUS_CMD_NAME_RELEASE, cmd_name))
+ {
+ if((errno == ESRCH))
+ return DBUS_RELEASE_NAME_REPLY_NON_EXISTENT;
+ else if (errno == EADDRINUSE)
+ return DBUS_RELEASE_NAME_REPLY_NOT_OWNER;
+ _dbus_verbose ("error releasing name '%s'. Error: %m, %d\n", name, errno);
+ return -errno;
+ }
+
+ _dbus_verbose("Name '%s' released\n", name);
+
+ return DBUS_RELEASE_NAME_REPLY_RELEASED;
+}
+
+dbus_bool_t
+kdbus_command_free(DBusTransport *transport,
+ __u64 offset)
+{
+ int result;
+ int fd;
+
+ if(!_dbus_transport_get_socket_fd(transport, &fd))
+ return FALSE;
+
+ do {
+ struct kdbus_cmd_free cmd = {0};
+ cmd.size = sizeof(cmd);
+ cmd.offset = offset;
+
+ result = ioctl(fd, KDBUS_CMD_FREE, &cmd);
+
+ } while (result < 0 && errno == EINTR);
+
+ return (result == 0);
+}
+
+/**
+ * Performs kdbus query of id of the given name
+ *
+ * @param name name to query for
+ * @param transport transport
+ * @param pInfo nameInfo structure address to store info about the name
+ * @return 0 on success, -errno if failed
+ */
+int
+kdbus_NameQuery(const char *name,
+ DBusTransport *transport,
+ struct nameInfo *pInfo)
+{
+ struct kdbus_cmd_info *cmd;
+ int ret;
+ int fd;
+ uint64_t size;
+ __u64 id = 0;
+
+ memset(pInfo, 0, sizeof(struct nameInfo));
+
+ if(!_dbus_transport_get_socket_fd(transport, &fd))
+ return -EPERM;
+
+ size = sizeof(*cmd);
+ if((name[0] == ':') && (name[1] == '1') && (name[2] == '.')) /* if name starts with ":1." it is a unique name and should be send as number */
+ id = strtoull(&name[3], NULL, 10);
+ if(id == 0)
+ size += KDBUS_ITEM_SIZE(strlen(name) + 1);
+
+ cmd = alloca(size);
+ if (!cmd)
+ {
+ _dbus_verbose("Error allocating memory for: %s,%s\n", _dbus_strerror (errno), _dbus_error_from_errno (errno));
+ return -errno;
+ }
+ memset(cmd, 0, sizeof(*cmd));
+
+ cmd->size = size;
+ cmd->id = id;
+ if(id == 0)
+ {
+ make_item_name(name, &(cmd->items[0]));
+ }
+
+ cmd->attach_flags = _KDBUS_ATTACH_ALL;
+
+ again:
+ ret = ioctl(fd, KDBUS_CMD_CONN_INFO, cmd);
+ if (ret < 0)
+ {
+ if(errno == EINTR)
+ goto again;
+ pInfo->uniqueId = 0;
+ return -errno;
+ }
+ else
+ {
+ struct kdbus_info *info;
+ struct kdbus_item *item;
+
+ info = (struct kdbus_info *)((char*)dbus_transport_get_pool_pointer(transport) + cmd->offset);
+ pInfo->uniqueId = info->id;
+ pInfo->flags = info->flags;
+
+ item = info->items;
+ while((uint8_t *)(item) < (uint8_t *)(info) + info->size)
+ {
+ switch (item->type)
+ {
+ case KDBUS_ITEM_PIDS:
+ pInfo->processId = item->pids.pid;
+ break;
+ case KDBUS_ITEM_CREDS:
+ pInfo->userId = item->creds.uid;
+ break;
+ case KDBUS_ITEM_SECLABEL:
+ pInfo->sec_label_len = item->size - KDBUS_ITEM_HEADER_SIZE - 1;
+ if(pInfo->sec_label_len != 0)
+ {
+ pInfo->sec_label = malloc(pInfo->sec_label_len);
+ if(pInfo->sec_label == NULL)
+ ret = -1;
+ else
+ memcpy(pInfo->sec_label, item->data, pInfo->sec_label_len);
+ }
+ break;
+ }
+
+ item = KDBUS_ITEM_NEXT(item);
+ }
+
+ if (!kdbus_command_free (transport, cmd->offset))
+ {
+ _dbus_verbose("kdbus error freeing pool: %d (%m)\n", errno);
+ free(pInfo->sec_label);
+ pInfo->sec_label = NULL;
+ return -errno;
+ }
+ }
+
+ return ret;
+}
+
+/*
+ * Asks kdbus for uid of the owner of the name given in the message
+ */
+dbus_bool_t
+kdbus_connection_get_unix_user(DBusTransport *transport,
+ const char *name,
+ unsigned long *uid,
+ DBusError *error)
+{
+ struct nameInfo info;
+ int inter_ret;
+ dbus_bool_t ret = FALSE;
+
+ inter_ret = kdbus_NameQuery(name, transport, &info);
+ if(inter_ret == 0) //name found
+ {
+ _dbus_verbose("User id:%llu\n", (unsigned long long) info.userId);
+ *uid = info.userId;
+ free(info.sec_label);
+ return TRUE;
+ }
+ else if((inter_ret == -ESRCH) || (inter_ret == -ENXIO)) //name has no owner
+ {
+ _dbus_verbose ("Name %s has no owner.\n", name);
+ dbus_set_error (error, DBUS_ERROR_NAME_HAS_NO_OWNER, "Could not get UID of name '%s': no such name", name);
+ }
+
+ else
+ {
+ _dbus_verbose("kdbus error determining UID: err %d (%m)\n", errno);
+ dbus_set_error (error, DBUS_ERROR_NAME_HAS_NO_OWNER, "Could not determine UID for '%s'", name);
+ }
+
+ return ret;
+}
+
+/*
+ * Asks kdbus for pid of the owner of the name given in the message
+ */
+dbus_bool_t
+kdbus_connection_get_unix_process_id(DBusTransport *transport,
+ const char *name,
+ unsigned long *pid,
+ DBusError *error)
+{
+ struct nameInfo info;
+ int inter_ret;
+ dbus_bool_t ret = FALSE;
+
+ inter_ret = kdbus_NameQuery(name, transport, &info);
+ if(inter_ret == 0) //name found
+ {
+ _dbus_verbose("Process id:%llu\n", (unsigned long long) info.processId);
+ *pid = info.processId;
+ free(info.sec_label);
+ return TRUE;
+ }
+ else if((inter_ret == -ESRCH) || (inter_ret == -ENXIO)) //name has no owner
+ dbus_set_error (error, DBUS_ERROR_FAILED, "Could not get PID of name '%s': no such name", name);
+ else
+ {
+ _dbus_verbose("kdbus error determining PID: err %d (%m)\n", errno);
+ dbus_set_error (error, DBUS_ERROR_FAILED, "Could not determine PID for '%s'", name);
+ }
+
+ return ret;
+}
+
+/**
+ * Opposing to dbus, in kdbus removes all match rules with given
+ * cookie, which in this implementation is equal to uniqe id.
+ *
+ * @param transport transport
+ * @param id connection id for which rules are to be removed
+ * @param cookie cookie of the rules to be removed
+ */
+static dbus_bool_t
+remove_match_kdbus (DBusTransport *transport,
+ __u64 cookie)
+{
+ struct kdbus_cmd_match cmd;
+ int fd;
+
+ if(!_dbus_transport_get_socket_fd(transport, &fd))
+ return FALSE;
+
+ cmd.cookie = cookie;
+ cmd.size = sizeof(struct kdbus_cmd_match);
+ cmd.flags = 0;
+
+ if(ioctl(fd, KDBUS_CMD_MATCH_REMOVE, &cmd))
+ {
+ _dbus_verbose("Failed removing match rule %llu, error: %d, %m\n", cookie, errno);
+ return FALSE;
+ }
+ else
+ {
+ _dbus_verbose("Match rule %llu removed correctly.\n", cookie);
+ return TRUE;
+ }
+}
+
+/*
+ * Removes match rule in kdbus on behalf of sender of the message
+ */
+dbus_bool_t
+kdbus_remove_match (DBusTransport *transport,
+ DBusList *rules,
+ const char *sender,
+ MatchRule *rule_to_remove,
+ DBusError *error)
+{
+ __u64 cookie = 0;
+ DBusList *link = NULL;
+
+ if (rules != NULL)
+ {
+ /* we traverse backward because bus_connection_remove_match_rule()
+ * removes the most-recently-added rule
+ */
+ link = _dbus_list_get_last_link (&rules);
+ while (link != NULL)
+ {
+ MatchRule *rule;
+ DBusList *prev;
+
+ rule = link->data;
+ prev = _dbus_list_get_prev_link (&rules, link);
+
+ if (match_rule_equal_lib (rule, rule_to_remove))
+ {
+ cookie = match_rule_get_cookie(rule);
+ break;
+ }
+
+ link = prev;
+ }
+ }
+
+ if(cookie == 0)
+ {
+ dbus_set_error (error, DBUS_ERROR_MATCH_RULE_NOT_FOUND,
+ "The given match rule wasn't found and can't be removed");
+ return FALSE;
+ }
+
+ if(!remove_match_kdbus (transport, cookie))
+ {
+ dbus_set_error (error, _dbus_error_from_errno (errno), "Could not remove match rule");
+ return FALSE;
+ }
+
+ return TRUE;
+}
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* kdbus-common.h kdbus related utils for daemon and libdbus
+ *
+ * Copyright (C) 2013 Samsung Electronics
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version and under the terms of the GNU
+ * Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef KDBUS_COMMON_H_
+#define KDBUS_COMMON_H_
+
+#include <dbus/dbus-types.h>
+#include <dbus/dbus-transport.h>
+#include <dbus/kdbus.h>
+#include "dbus-signals.h"
+
+#define KDBUS_ALIGN8(l) (((l) + 7) & ~7)
+
+#define KDBUS_ITEM_HEADER_SIZE offsetof(struct kdbus_item, data)
+#define KDBUS_ITEM_SIZE(s) KDBUS_ALIGN8(KDBUS_ITEM_HEADER_SIZE + (s))
+#define KDBUS_ITEM_NEXT(item) \
+ (typeof(item))(((uint8_t *)item) + KDBUS_ALIGN8((item)->size))
+#define KDBUS_ITEM_FOREACH(item, head, first) \
+ for (item = (head)->first; \
+ (uint8_t *)(item) < (uint8_t *)(head) + (head)->size; \
+ item = KDBUS_ITEM_NEXT(item))
+
+#define KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE 0x00200000 /* maximum size of message header and items */
+
+
+
+// Restore if DBus policy will be applied in kdbus somehow
+//#define POLICY_TO_KDBUS
+
+struct nameInfo
+{
+ __u64 uniqueId;
+ __u64 flags;
+ __u64 userId;
+ __u64 processId;
+ __u32 sec_label_len;
+ char *sec_label;
+};
+
+__u64 sender_name_to_id (const char* name, DBusError* error);
+int kdbus_NameQuery (const char *name, DBusTransport *transport, struct nameInfo *pInfo);
+dbus_bool_t kdbus_connection_get_unix_user (DBusTransport *connection, const char *name, unsigned long *uid, DBusError *error);
+dbus_bool_t kdbus_connection_get_unix_process_id (DBusTransport *connection, const char *name, unsigned long *uid, DBusError *error);
+
+dbus_bool_t register_kdbus_policy (const char *name, DBusTransport *transport, unsigned long int uid);
+int request_kdbus_name (DBusTransport* transport, const char *name, const __u64 flags);
+int release_kdbus_name (DBusTransport* transport, const char *name);
+
+dbus_bool_t kdbus_remove_match (DBusTransport *transport, DBusList *rules, const char *sender,
+ MatchRule *rule_to_remove, DBusError *error);
+
+dbus_bool_t kdbus_command_free (DBusTransport *transport, __u64 offset);
+
+#endif /* KDBUS_COMMON_H_ */
--- /dev/null
+/*
+ * kdbus is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ */
+
+#ifndef _UAPI_KDBUS_H_
+#define _UAPI_KDBUS_H_
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#define KDBUS_IOCTL_MAGIC 0x95
+#define KDBUS_SRC_ID_KERNEL (0)
+#define KDBUS_DST_ID_NAME (0)
+#define KDBUS_MATCH_ID_ANY (~0ULL)
+#define KDBUS_DST_ID_BROADCAST (~0ULL)
+#define KDBUS_FLAG_NEGOTIATE (1ULL << 63)
+
+/**
+ * struct kdbus_notify_id_change - name registry change message
+ * @id: New or former owner of the name
+ * @flags: flags field from KDBUS_HELLO_*
+ *
+ * Sent from kernel to userspace when the owner or activator of
+ * a well-known name changes.
+ *
+ * Attached to:
+ * KDBUS_ITEM_ID_ADD
+ * KDBUS_ITEM_ID_REMOVE
+ */
+struct kdbus_notify_id_change {
+ __u64 id;
+ __u64 flags;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_notify_name_change - name registry change message
+ * @old_id: ID and flags of former owner of a name
+ * @new_id: ID and flags of new owner of a name
+ * @name: Well-known name
+ *
+ * Sent from kernel to userspace when the owner or activator of
+ * a well-known name changes.
+ *
+ * Attached to:
+ * KDBUS_ITEM_NAME_ADD
+ * KDBUS_ITEM_NAME_REMOVE
+ * KDBUS_ITEM_NAME_CHANGE
+ */
+struct kdbus_notify_name_change {
+ struct kdbus_notify_id_change old_id;
+ struct kdbus_notify_id_change new_id;
+ char name[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_creds - process credentials
+ * @uid: User ID
+ * @euid: Effective UID
+ * @suid: Saved UID
+ * @fsuid: Filesystem UID
+ * @gid: Group ID
+ * @egid: Effective GID
+ * @sgid: Saved GID
+ * @fsgid: Filesystem GID
+ *
+ * Attached to:
+ * KDBUS_ITEM_CREDS
+ */
+struct kdbus_creds {
+ __u64 uid;
+ __u64 euid;
+ __u64 suid;
+ __u64 fsuid;
+ __u64 gid;
+ __u64 egid;
+ __u64 sgid;
+ __u64 fsgid;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_pids - process identifiers
+ * @pid: Process ID
+ * @tid: Thread ID
+ * @ppid: Parent process ID
+ *
+ * The PID and TID of a process.
+ *
+ * Attached to:
+ * KDBUS_ITEM_PIDS
+ */
+struct kdbus_pids {
+ __u64 pid;
+ __u64 tid;
+ __u64 ppid;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_caps - process capabilities
+ * @last_cap: Highest currently known capability bit
+ * @caps: Variable number of 32-bit capabilities flags
+ *
+ * Contains a variable number of 32-bit capabilities flags.
+ *
+ * Attached to:
+ * KDBUS_ITEM_CAPS
+ */
+struct kdbus_caps {
+ __u32 last_cap;
+ __u32 caps[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_audit - audit information
+ * @sessionid: The audit session ID
+ * @loginuid: The audit login uid
+ *
+ * Attached to:
+ * KDBUS_ITEM_AUDIT
+ */
+struct kdbus_audit {
+ __u32 sessionid;
+ __u32 loginuid;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_timestamp
+ * @seqnum: Global per-domain message sequence number
+ * @monotonic_ns: Monotonic timestamp, in nanoseconds
+ * @realtime_ns: Realtime timestamp, in nanoseconds
+ *
+ * Attached to:
+ * KDBUS_ITEM_TIMESTAMP
+ */
+struct kdbus_timestamp {
+ __u64 seqnum;
+ __u64 monotonic_ns;
+ __u64 realtime_ns;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_vec - I/O vector for kdbus payload items
+ * @size: The size of the vector
+ * @address: Memory address of data buffer
+ * @offset: Offset in the in-message payload memory,
+ * relative to the message head
+ *
+ * Attached to:
+ * KDBUS_ITEM_PAYLOAD_VEC, KDBUS_ITEM_PAYLOAD_OFF
+ */
+struct kdbus_vec {
+ __u64 size;
+ union {
+ __u64 address;
+ __u64 offset;
+ };
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_bloom_parameter - bus-wide bloom parameters
+ * @size: Size of the bit field in bytes (m / 8)
+ * @n_hash: Number of hash functions used (k)
+ */
+struct kdbus_bloom_parameter {
+ __u64 size;
+ __u64 n_hash;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_bloom_filter - bloom filter containing n elements
+ * @generation: Generation of the element set in the filter
+ * @data: Bit field, multiple of 8 bytes
+ */
+struct kdbus_bloom_filter {
+ __u64 generation;
+ __u64 data[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_memfd - a kdbus memfd
+ * @start: The offset into the memfd where the segment starts
+ * @size: The size of the memfd segment
+ * @fd: The file descriptor number
+ * @__pad: Padding to ensure proper alignment and size
+ *
+ * Attached to:
+ * KDBUS_ITEM_PAYLOAD_MEMFD
+ */
+struct kdbus_memfd {
+ __u64 start;
+ __u64 size;
+ int fd;
+ __u32 __pad;
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_name - a registered well-known name with its flags
+ * @flags: Flags from KDBUS_NAME_*
+ * @name: Well-known name
+ *
+ * Attached to:
+ * KDBUS_ITEM_OWNED_NAME
+ */
+struct kdbus_name {
+ __u64 flags;
+ char name[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_policy_access_type - permissions of a policy record
+ * @_KDBUS_POLICY_ACCESS_NULL: Uninitialized/invalid
+ * @KDBUS_POLICY_ACCESS_USER: Grant access to a uid
+ * @KDBUS_POLICY_ACCESS_GROUP: Grant access to gid
+ * @KDBUS_POLICY_ACCESS_WORLD: World-accessible
+ */
+enum kdbus_policy_access_type {
+ _KDBUS_POLICY_ACCESS_NULL,
+ KDBUS_POLICY_ACCESS_USER,
+ KDBUS_POLICY_ACCESS_GROUP,
+ KDBUS_POLICY_ACCESS_WORLD,
+};
+
+/**
+ * enum kdbus_policy_access_flags - mode flags
+ * @KDBUS_POLICY_OWN: Allow to own a well-known name
+ * Implies KDBUS_POLICY_TALK and KDBUS_POLICY_SEE
+ * @KDBUS_POLICY_TALK: Allow communication to a well-known name
+ * Implies KDBUS_POLICY_SEE
+ * @KDBUS_POLICY_SEE: Allow to see a well-known name
+ */
+enum kdbus_policy_type {
+ KDBUS_POLICY_SEE = 0,
+ KDBUS_POLICY_TALK,
+ KDBUS_POLICY_OWN,
+};
+
+/**
+ * struct kdbus_policy_access - policy access item
+ * @type: One of KDBUS_POLICY_ACCESS_* types
+ * @access: Access to grant
+ * @id: For KDBUS_POLICY_ACCESS_USER, the uid
+ * For KDBUS_POLICY_ACCESS_GROUP, the gid
+ */
+struct kdbus_policy_access {
+ __u64 type; /* USER, GROUP, WORLD */
+ __u64 access; /* OWN, TALK, SEE */
+ __u64 id; /* uid, gid, 0 */
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_attach_flags - flags for metadata attachments
+ * @KDBUS_ATTACH_TIMESTAMP: Timestamp
+ * @KDBUS_ATTACH_CREDS: Credentials
+ * @KDBUS_ATTACH_PIDS: PIDs
+ * @KDBUS_ATTACH_AUXGROUPS: Auxiliary groups
+ * @KDBUS_ATTACH_NAMES: Well-known names
+ * @KDBUS_ATTACH_TID_COMM: The "comm" process identifier of the TID
+ * @KDBUS_ATTACH_PID_COMM: The "comm" process identifier of the PID
+ * @KDBUS_ATTACH_EXE: The path of the executable
+ * @KDBUS_ATTACH_CMDLINE: The process command line
+ * @KDBUS_ATTACH_CGROUP: The croup membership
+ * @KDBUS_ATTACH_CAPS: The process capabilities
+ * @KDBUS_ATTACH_SECLABEL: The security label
+ * @KDBUS_ATTACH_AUDIT: The audit IDs
+ * @KDBUS_ATTACH_CONN_DESCRIPTION: The human-readable connection name
+ * @_KDBUS_ATTACH_ALL: All of the above
+ * @_KDBUS_ATTACH_ANY: Wildcard match to enable any kind of
+ * metatdata.
+ */
+enum kdbus_attach_flags {
+ KDBUS_ATTACH_TIMESTAMP = 1ULL << 0,
+ KDBUS_ATTACH_CREDS = 1ULL << 1,
+ KDBUS_ATTACH_PIDS = 1ULL << 2,
+ KDBUS_ATTACH_AUXGROUPS = 1ULL << 3,
+ KDBUS_ATTACH_NAMES = 1ULL << 4,
+ KDBUS_ATTACH_TID_COMM = 1ULL << 5,
+ KDBUS_ATTACH_PID_COMM = 1ULL << 6,
+ KDBUS_ATTACH_EXE = 1ULL << 7,
+ KDBUS_ATTACH_CMDLINE = 1ULL << 8,
+ KDBUS_ATTACH_CGROUP = 1ULL << 9,
+ KDBUS_ATTACH_CAPS = 1ULL << 10,
+ KDBUS_ATTACH_SECLABEL = 1ULL << 11,
+ KDBUS_ATTACH_AUDIT = 1ULL << 12,
+ KDBUS_ATTACH_CONN_DESCRIPTION = 1ULL << 13,
+ _KDBUS_ATTACH_ALL = (1ULL << 14) - 1,
+ _KDBUS_ATTACH_ANY = ~0ULL
+};
+
+/**
+ * enum kdbus_item_type - item types to chain data in a list
+ * @_KDBUS_ITEM_NULL: Uninitialized/invalid
+ * @_KDBUS_ITEM_USER_BASE: Start of user items
+ * @KDBUS_ITEM_NEGOTIATE: Negotiate supported items
+ * @KDBUS_ITEM_PAYLOAD_VEC: Vector to data
+ * @KDBUS_ITEM_PAYLOAD_OFF: Data at returned offset to message head
+ * @KDBUS_ITEM_PAYLOAD_MEMFD: Data as sealed memfd
+ * @KDBUS_ITEM_FDS: Attached file descriptors
+ * @KDBUS_ITEM_CANCEL_FD: FD used to cancel a synchronous
+ * operation by writing to it from
+ * userspace
+ * @KDBUS_ITEM_BLOOM_PARAMETER: Bus-wide bloom parameters, used with
+ * KDBUS_CMD_BUS_MAKE, carries a
+ * struct kdbus_bloom_parameter
+ * @KDBUS_ITEM_BLOOM_FILTER: Bloom filter carried with a message,
+ * used to match against a bloom mask of a
+ * connection, carries a struct
+ * kdbus_bloom_filter
+ * @KDBUS_ITEM_BLOOM_MASK: Bloom mask used to match against a
+ * message'sbloom filter
+ * @KDBUS_ITEM_DST_NAME: Destination's well-known name
+ * @KDBUS_ITEM_MAKE_NAME: Name of domain, bus, endpoint
+ * @KDBUS_ITEM_ATTACH_FLAGS_SEND: Attach-flags, used for updating which
+ * metadata a connection opts in to send
+ * @KDBUS_ITEM_ATTACH_FLAGS_RECV: Attach-flags, used for updating which
+ * metadata a connection requests to
+ * receive for each reeceived message
+ * @KDBUS_ITEM_ID: Connection ID
+ * @KDBUS_ITEM_NAME: Well-know name with flags
+ * @_KDBUS_ITEM_ATTACH_BASE: Start of metadata attach items
+ * @KDBUS_ITEM_TIMESTAMP: Timestamp
+ * @KDBUS_ITEM_CREDS: Process credentials
+ * @KDBUS_ITEM_PIDS: Process identifiers
+ * @KDBUS_ITEM_AUXGROUPS: Auxiliary process groups
+ * @KDBUS_ITEM_OWNED_NAME: A name owned by the associated
+ * connection
+ * @KDBUS_ITEM_TID_COMM: Thread ID "comm" identifier
+ * (Don't trust this, see below.)
+ * @KDBUS_ITEM_PID_COMM: Process ID "comm" identifier
+ * (Don't trust this, see below.)
+ * @KDBUS_ITEM_EXE: The path of the executable
+ * (Don't trust this, see below.)
+ * @KDBUS_ITEM_CMDLINE: The process command line
+ * (Don't trust this, see below.)
+ * @KDBUS_ITEM_CGROUP: The croup membership
+ * @KDBUS_ITEM_CAPS: The process capabilities
+ * @KDBUS_ITEM_SECLABEL: The security label
+ * @KDBUS_ITEM_AUDIT: The audit IDs
+ * @KDBUS_ITEM_CONN_DESCRIPTION: The connection's human-readable name
+ * (debugging)
+ * @_KDBUS_ITEM_POLICY_BASE: Start of policy items
+ * @KDBUS_ITEM_POLICY_ACCESS: Policy access block
+ * @_KDBUS_ITEM_KERNEL_BASE: Start of kernel-generated message items
+ * @KDBUS_ITEM_NAME_ADD: Notification in kdbus_notify_name_change
+ * @KDBUS_ITEM_NAME_REMOVE: Notification in kdbus_notify_name_change
+ * @KDBUS_ITEM_NAME_CHANGE: Notification in kdbus_notify_name_change
+ * @KDBUS_ITEM_ID_ADD: Notification in kdbus_notify_id_change
+ * @KDBUS_ITEM_ID_REMOVE: Notification in kdbus_notify_id_change
+ * @KDBUS_ITEM_REPLY_TIMEOUT: Timeout has been reached
+ * @KDBUS_ITEM_REPLY_DEAD: Destination died
+ *
+ * N.B: The process and thread COMM fields, as well as the CMDLINE and
+ * EXE fields may be altered by unprivileged processes und should
+ * hence *not* used for security decisions. Peers should make use of
+ * these items only for informational purposes, such as generating log
+ * records.
+ */
+enum kdbus_item_type {
+ _KDBUS_ITEM_NULL,
+ _KDBUS_ITEM_USER_BASE,
+ KDBUS_ITEM_NEGOTIATE = _KDBUS_ITEM_USER_BASE,
+ KDBUS_ITEM_PAYLOAD_VEC,
+ KDBUS_ITEM_PAYLOAD_OFF,
+ KDBUS_ITEM_PAYLOAD_MEMFD,
+ KDBUS_ITEM_FDS,
+ KDBUS_ITEM_CANCEL_FD,
+ KDBUS_ITEM_BLOOM_PARAMETER,
+ KDBUS_ITEM_BLOOM_FILTER,
+ KDBUS_ITEM_BLOOM_MASK,
+ KDBUS_ITEM_DST_NAME,
+ KDBUS_ITEM_MAKE_NAME,
+ KDBUS_ITEM_ATTACH_FLAGS_SEND,
+ KDBUS_ITEM_ATTACH_FLAGS_RECV,
+ KDBUS_ITEM_ID,
+ KDBUS_ITEM_NAME,
+ KDBUS_ITEM_DST_ID,
+
+ /* keep these item types in sync with KDBUS_ATTACH_* flags */
+ _KDBUS_ITEM_ATTACH_BASE = 0x1000,
+ KDBUS_ITEM_TIMESTAMP = _KDBUS_ITEM_ATTACH_BASE,
+ KDBUS_ITEM_CREDS,
+ KDBUS_ITEM_PIDS,
+ KDBUS_ITEM_AUXGROUPS,
+ KDBUS_ITEM_OWNED_NAME,
+ KDBUS_ITEM_TID_COMM,
+ KDBUS_ITEM_PID_COMM,
+ KDBUS_ITEM_EXE,
+ KDBUS_ITEM_CMDLINE,
+ KDBUS_ITEM_CGROUP,
+ KDBUS_ITEM_CAPS,
+ KDBUS_ITEM_SECLABEL,
+ KDBUS_ITEM_AUDIT,
+ KDBUS_ITEM_CONN_DESCRIPTION,
+
+ _KDBUS_ITEM_POLICY_BASE = 0x2000,
+ KDBUS_ITEM_POLICY_ACCESS = _KDBUS_ITEM_POLICY_BASE,
+
+ _KDBUS_ITEM_KERNEL_BASE = 0x8000,
+ KDBUS_ITEM_NAME_ADD = _KDBUS_ITEM_KERNEL_BASE,
+ KDBUS_ITEM_NAME_REMOVE,
+ KDBUS_ITEM_NAME_CHANGE,
+ KDBUS_ITEM_ID_ADD,
+ KDBUS_ITEM_ID_REMOVE,
+ KDBUS_ITEM_REPLY_TIMEOUT,
+ KDBUS_ITEM_REPLY_DEAD,
+};
+
+/**
+ * struct kdbus_item - chain of data blocks
+ * @size: Overall data record size
+ * @type: Kdbus_item type of data
+ * @data: Generic bytes
+ * @data32: Generic 32 bit array
+ * @data64: Generic 64 bit array
+ * @str: Generic string
+ * @id: Connection ID
+ * @vec: KDBUS_ITEM_PAYLOAD_VEC
+ * @creds: KDBUS_ITEM_CREDS
+ * @audit: KDBUS_ITEM_AUDIT
+ * @timestamp: KDBUS_ITEM_TIMESTAMP
+ * @name: KDBUS_ITEM_NAME
+ * @bloom_parameter: KDBUS_ITEM_BLOOM_PARAMETER
+ * @bloom_filter: KDBUS_ITEM_BLOOM_FILTER
+ * @memfd: KDBUS_ITEM_PAYLOAD_MEMFD
+ * @name_change: KDBUS_ITEM_NAME_ADD
+ * KDBUS_ITEM_NAME_REMOVE
+ * KDBUS_ITEM_NAME_CHANGE
+ * @id_change: KDBUS_ITEM_ID_ADD
+ * KDBUS_ITEM_ID_REMOVE
+ * @policy: KDBUS_ITEM_POLICY_ACCESS
+ */
+struct kdbus_item {
+ __u64 size;
+ __u64 type;
+ union {
+ __u8 data[0];
+ __u32 data32[0];
+ __u64 data64[0];
+ char str[0];
+
+ __u64 id;
+ struct kdbus_vec vec;
+ struct kdbus_creds creds;
+ struct kdbus_pids pids;
+ struct kdbus_audit audit;
+ struct kdbus_caps caps;
+ struct kdbus_timestamp timestamp;
+ struct kdbus_name name;
+ struct kdbus_bloom_parameter bloom_parameter;
+ struct kdbus_bloom_filter bloom_filter;
+ struct kdbus_memfd memfd;
+ int fds[0];
+ struct kdbus_notify_name_change name_change;
+ struct kdbus_notify_id_change id_change;
+ struct kdbus_policy_access policy_access;
+ };
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_msg_flags - type of message
+ * @KDBUS_MSG_EXPECT_REPLY: Expect a reply message, used for
+ * method calls. The userspace-supplied
+ * cookie identifies the message and the
+ * respective reply carries the cookie
+ * in cookie_reply
+ * @KDBUS_MSG_NO_AUTO_START: Do not start a service if the addressed
+ * name is not currently active. This flag is
+ * not looked at by the kernel but only
+ * serves as hint for userspace implementations.
+ * @KDBUS_MSG_SIGNAL: Treat this message as signal
+ */
+enum kdbus_msg_flags {
+ KDBUS_MSG_EXPECT_REPLY = 1ULL << 0,
+ KDBUS_MSG_NO_AUTO_START = 1ULL << 1,
+ KDBUS_MSG_SIGNAL = 1ULL << 2,
+};
+
+/**
+ * enum kdbus_payload_type - type of payload carried by message
+ * @KDBUS_PAYLOAD_KERNEL: Kernel-generated simple message
+ * @KDBUS_PAYLOAD_DBUS: D-Bus marshalling "DBusDBus"
+ *
+ * Any payload-type is accepted. Common types will get added here once
+ * established.
+ */
+enum kdbus_payload_type {
+ KDBUS_PAYLOAD_KERNEL,
+ KDBUS_PAYLOAD_DBUS = 0x4442757344427573ULL,
+};
+
+/**
+ * struct kdbus_msg - the representation of a kdbus message
+ * @size: Total size of the message
+ * @flags: Message flags (KDBUS_MSG_*), userspace → kernel
+ * @priority: Message queue priority value
+ * @dst_id: 64-bit ID of the destination connection
+ * @src_id: 64-bit ID of the source connection
+ * @payload_type: Payload type (KDBUS_PAYLOAD_*)
+ * @cookie: Userspace-supplied cookie, for the connection
+ * to identify its messages
+ * @timeout_ns: The time to wait for a message reply from the peer.
+ * If there is no reply, and the send command is
+ * executed asynchronously, a kernel-generated message
+ * with an attached KDBUS_ITEM_REPLY_TIMEOUT item
+ * is sent to @src_id. For synchronously executed send
+ * command, the value denotes the maximum time the call
+ * blocks to wait for a reply. The timeout is expected in
+ * nanoseconds and as absolute CLOCK_MONOTONIC value.
+ * @cookie_reply: A reply to the requesting message with the same
+ * cookie. The requesting connection can match its
+ * request and the reply with this value
+ * @items: A list of kdbus_items containing the message payload
+ */
+struct kdbus_msg {
+ __u64 size;
+ __u64 flags;
+ __s64 priority;
+ __u64 dst_id;
+ __u64 src_id;
+ __u64 payload_type;
+ __u64 cookie;
+ union {
+ __u64 timeout_ns;
+ __u64 cookie_reply;
+ };
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_msg_info - returned message container
+ * @offset: Offset of kdbus_msg slice in pool
+ * @msg_size: Copy of the kdbus_msg.size field
+ * @return_flags: Command return flags, kernel → userspace
+ */
+struct kdbus_msg_info {
+ __u64 offset;
+ __u64 msg_size;
+ __u64 return_flags;
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_send_flags - flags for sending messages
+ * @KDBUS_SEND_SYNC_REPLY: Wait for destination connection to
+ * reply to this message. The
+ * KDBUS_CMD_SEND ioctl() will block
+ * until the reply is received, and
+ * reply in struct kdbus_cmd_send will
+ * yield the offset in the sender's pool
+ * where the reply can be found.
+ * This flag is only valid if
+ * @KDBUS_MSG_EXPECT_REPLY is set as well.
+ */
+enum kdbus_send_flags {
+ KDBUS_SEND_SYNC_REPLY = 1ULL << 0,
+};
+
+/**
+ * struct kdbus_cmd_send - send message
+ * @size: Overall size of this structure
+ * @flags: Flags to change send behavior (KDBUS_SEND_*)
+ * @return_flags: Command return flags, kernel → userspace
+ * @msg_address: Storage address of the kdbus_msg to send
+ * @reply: Storage for message reply if KDBUS_SEND_SYNC_REPLY
+ * was given
+ * @items: Additional items for this command
+ */
+struct kdbus_cmd_send {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __u64 msg_address;
+ struct kdbus_msg_info reply;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_recv_flags - flags for de-queuing messages
+ * @KDBUS_RECV_PEEK: Return the next queued message without
+ * actually de-queuing it, and without installing
+ * any file descriptors or other resources. It is
+ * usually used to determine the activating
+ * connection of a bus name.
+ * @KDBUS_RECV_DROP: Drop and free the next queued message and all
+ * its resources without actually receiving it.
+ * @KDBUS_RECV_USE_PRIORITY: Only de-queue messages with the specified or
+ * higher priority (lowest values); if not set,
+ * the priority value is ignored.
+ */
+enum kdbus_recv_flags {
+ KDBUS_RECV_PEEK = 1ULL << 0,
+ KDBUS_RECV_DROP = 1ULL << 1,
+ KDBUS_RECV_USE_PRIORITY = 1ULL << 2,
+};
+
+/**
+ * enum kdbus_recv_return_flags - return flags for message receive commands
+ * @KDBUS_RECV_RETURN_INCOMPLETE_FDS: One or more file descriptors could not
+ * be installed. These descriptors in
+ * KDBUS_ITEM_FDS will carry the value -1.
+ * @KDBUS_RECV_RETURN_DROPPED_MSGS: There have been dropped messages since
+ * the last time a message was received.
+ * The 'dropped_msgs' counter contains the
+ * number of messages dropped pool
+ * overflows or other missed broadcasts.
+ */
+enum kdbus_recv_return_flags {
+ KDBUS_RECV_RETURN_INCOMPLETE_FDS = 1ULL << 0,
+ KDBUS_RECV_RETURN_DROPPED_MSGS = 1ULL << 1,
+};
+
+/**
+ * struct kdbus_cmd_recv - struct to de-queue a buffered message
+ * @size: Overall size of this object
+ * @flags: KDBUS_RECV_* flags, userspace → kernel
+ * @return_flags: Command return flags, kernel → userspace
+ * @priority: Minimum priority of the messages to de-queue. Lowest
+ * values have the highest priority.
+ * @dropped_msgs: In case there were any dropped messages since the last
+ * time a message was received, this will be set to the
+ * number of lost messages and
+ * KDBUS_RECV_RETURN_DROPPED_MSGS will be set in
+ * 'return_flags'. This can only happen if the ioctl
+ * returns 0 or EAGAIN.
+ * @msg: Return storage for received message.
+ * @items: Additional items for this command.
+ *
+ * This struct is used with the KDBUS_CMD_RECV ioctl.
+ */
+struct kdbus_cmd_recv {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __s64 priority;
+ __u64 dropped_msgs;
+ struct kdbus_msg_info msg;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_cmd_free - struct to free a slice of memory in the pool
+ * @size: Overall size of this structure
+ * @flags: Flags for the free command, userspace → kernel
+ * @return_flags: Command return flags, kernel → userspace
+ * @offset: The offset of the memory slice, as returned by other
+ * ioctls
+ * @items: Additional items to modify the behavior
+ *
+ * This struct is used with the KDBUS_CMD_FREE ioctl.
+ */
+struct kdbus_cmd_free {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __u64 offset;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_hello_flags - flags for struct kdbus_cmd_hello
+ * @KDBUS_HELLO_ACCEPT_FD: The connection allows the reception of
+ * any passed file descriptors
+ * @KDBUS_HELLO_ACTIVATOR: Special-purpose connection which registers
+ * a well-know name for a process to be started
+ * when traffic arrives
+ * @KDBUS_HELLO_POLICY_HOLDER: Special-purpose connection which registers
+ * policy entries for a name. The provided name
+ * is not activated and not registered with the
+ * name database, it only allows unprivileged
+ * connections to acquire a name, talk or discover
+ * a service
+ * @KDBUS_HELLO_MONITOR: Special-purpose connection to monitor
+ * bus traffic
+ */
+enum kdbus_hello_flags {
+ KDBUS_HELLO_ACCEPT_FD = 1ULL << 0,
+ KDBUS_HELLO_ACTIVATOR = 1ULL << 1,
+ KDBUS_HELLO_POLICY_HOLDER = 1ULL << 2,
+ KDBUS_HELLO_MONITOR = 1ULL << 3,
+};
+
+/**
+ * struct kdbus_cmd_hello - struct to say hello to kdbus
+ * @size: The total size of the structure
+ * @flags: Connection flags (KDBUS_HELLO_*), userspace → kernel
+ * @return_flags: Command return flags, kernel → userspace
+ * @attach_flags_send: Mask of metadata to attach to each message sent
+ * off by this connection (KDBUS_ATTACH_*)
+ * @attach_flags_recv: Mask of metadata to attach to each message receieved
+ * by the new connection (KDBUS_ATTACH_*)
+ * @bus_flags: The flags field copied verbatim from the original
+ * KDBUS_CMD_BUS_MAKE ioctl. It's intended to be useful
+ * to do negotiation of features of the payload that is
+ * transferred (kernel → userspace)
+ * @id: The ID of this connection (kernel → userspace)
+ * @pool_size: Size of the connection's buffer where the received
+ * messages are placed
+ * @offset: Pool offset where items are returned to report
+ * additional information about the bus and the newly
+ * created connection.
+ * @items_size: Size of buffer returned in the pool slice at @offset.
+ * @id128: Unique 128-bit ID of the bus (kernel → userspace)
+ * @items: A list of items
+ *
+ * This struct is used with the KDBUS_CMD_HELLO ioctl.
+ */
+struct kdbus_cmd_hello {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __u64 attach_flags_send;
+ __u64 attach_flags_recv;
+ __u64 bus_flags;
+ __u64 id;
+ __u64 pool_size;
+ __u64 offset;
+ __u64 items_size;
+ __u8 id128[16];
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_info - connection information
+ * @size: total size of the struct
+ * @id: 64bit object ID
+ * @flags: object creation flags
+ * @items: list of items
+ *
+ * Note that the user is responsible for freeing the allocated memory with
+ * the KDBUS_CMD_FREE ioctl.
+ */
+struct kdbus_info {
+ __u64 size;
+ __u64 id;
+ __u64 flags;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_list_flags - what to include into the returned list
+ * @KDBUS_LIST_UNIQUE: active connections
+ * @KDBUS_LIST_ACTIVATORS: activator connections
+ * @KDBUS_LIST_NAMES: known well-known names
+ * @KDBUS_LIST_QUEUED: queued-up names
+ */
+enum kdbus_list_flags {
+ KDBUS_LIST_UNIQUE = 1ULL << 0,
+ KDBUS_LIST_NAMES = 1ULL << 1,
+ KDBUS_LIST_ACTIVATORS = 1ULL << 2,
+ KDBUS_LIST_QUEUED = 1ULL << 3,
+};
+
+/**
+ * struct kdbus_cmd_list - list connections
+ * @size: overall size of this object
+ * @flags: flags for the query (KDBUS_LIST_*), userspace → kernel
+ * @return_flags: command return flags, kernel → userspace
+ * @offset: Offset in the caller's pool buffer where an array of
+ * kdbus_info objects is stored.
+ * The user must use KDBUS_CMD_FREE to free the
+ * allocated memory.
+ * @list_size: size of returned list in bytes
+ * @items: Items for the command. Reserved for future use.
+ *
+ * This structure is used with the KDBUS_CMD_LIST ioctl.
+ */
+struct kdbus_cmd_list {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __u64 offset;
+ __u64 list_size;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * struct kdbus_cmd_info - struct used for KDBUS_CMD_CONN_INFO ioctl
+ * @size: The total size of the struct
+ * @flags: Flags for this ioctl, userspace → kernel
+ * @return_flags: Command return flags, kernel → userspace
+ * @id: The 64-bit ID of the connection. If set to zero, passing
+ * @name is required. kdbus will look up the name to
+ * determine the ID in this case.
+ * @attach_flags: Set of attach flags to specify the set of information
+ * to receive, userspace → kernel
+ * @offset: Returned offset in the caller's pool buffer where the
+ * kdbus_info struct result is stored. The user must
+ * use KDBUS_CMD_FREE to free the allocated memory.
+ * @info_size: Output buffer to report size of data at @offset.
+ * @items: The optional item list, containing the
+ * well-known name to look up as a KDBUS_ITEM_NAME.
+ * Only needed in case @id is zero.
+ *
+ * On success, the KDBUS_CMD_CONN_INFO ioctl will return 0 and @offset will
+ * tell the user the offset in the connection pool buffer at which to find the
+ * result in a struct kdbus_info.
+ */
+struct kdbus_cmd_info {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __u64 id;
+ __u64 attach_flags;
+ __u64 offset;
+ __u64 info_size;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_cmd_match_flags - flags to control the KDBUS_CMD_MATCH_ADD ioctl
+ * @KDBUS_MATCH_REPLACE: If entries with the supplied cookie already
+ * exists, remove them before installing the new
+ * matches.
+ */
+enum kdbus_cmd_match_flags {
+ KDBUS_MATCH_REPLACE = 1ULL << 0,
+};
+
+/**
+ * struct kdbus_cmd_match - struct to add or remove matches
+ * @size: The total size of the struct
+ * @flags: Flags for match command (KDBUS_MATCH_*),
+ * userspace → kernel
+ * @return_flags: Command return flags, kernel → userspace
+ * @cookie: Userspace supplied cookie. When removing, the cookie
+ * identifies the match to remove
+ * @items: A list of items for additional information
+ *
+ * This structure is used with the KDBUS_CMD_MATCH_ADD and
+ * KDBUS_CMD_MATCH_REMOVE ioctl.
+ */
+struct kdbus_cmd_match {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ __u64 cookie;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_make_flags - Flags for KDBUS_CMD_{BUS,ENDPOINT}_MAKE
+ * @KDBUS_MAKE_ACCESS_GROUP: Make the bus or endpoint node group-accessible
+ * @KDBUS_MAKE_ACCESS_WORLD: Make the bus or endpoint node world-accessible
+ */
+enum kdbus_make_flags {
+ KDBUS_MAKE_ACCESS_GROUP = 1ULL << 0,
+ KDBUS_MAKE_ACCESS_WORLD = 1ULL << 1,
+};
+
+/**
+ * enum kdbus_name_flags - flags for KDBUS_CMD_NAME_ACQUIRE
+ * @KDBUS_NAME_REPLACE_EXISTING: Try to replace name of other connections
+ * @KDBUS_NAME_ALLOW_REPLACEMENT: Allow the replacement of the name
+ * @KDBUS_NAME_QUEUE: Name should be queued if busy
+ * @KDBUS_NAME_IN_QUEUE: Name is queued
+ * @KDBUS_NAME_ACTIVATOR: Name is owned by a activator connection
+ * @KDBUS_NAME_PRIMARY: Primary owner of the name
+ * @KDBUS_NAME_ACQUIRED: Name was acquired/queued _now_
+ */
+enum kdbus_name_flags {
+ KDBUS_NAME_REPLACE_EXISTING = 1ULL << 0,
+ KDBUS_NAME_ALLOW_REPLACEMENT = 1ULL << 1,
+ KDBUS_NAME_QUEUE = 1ULL << 2,
+ KDBUS_NAME_IN_QUEUE = 1ULL << 3,
+ KDBUS_NAME_ACTIVATOR = 1ULL << 4,
+ KDBUS_NAME_PRIMARY = 1ULL << 5,
+ KDBUS_NAME_ACQUIRED = 1ULL << 6,
+};
+
+/**
+ * struct kdbus_cmd - generic ioctl payload
+ * @size: Overall size of this structure
+ * @flags: Flags for this ioctl, userspace → kernel
+ * @return_flags: Ioctl return flags, kernel → userspace
+ * @items: Additional items to modify the behavior
+ *
+ * This is a generic ioctl payload object. It's used by all ioctls that only
+ * take flags and items as input.
+ */
+struct kdbus_cmd {
+ __u64 size;
+ __u64 flags;
+ __u64 return_flags;
+ struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * Ioctl API
+ *
+ * KDBUS_CMD_BUS_MAKE: After opening the "control" node, this command
+ * creates a new bus with the specified
+ * name. The bus is immediately shut down and
+ * cleaned up when the opened file descriptor is
+ * closed.
+ *
+ * KDBUS_CMD_ENDPOINT_MAKE: Creates a new named special endpoint to talk to
+ * the bus. Such endpoints usually carry a more
+ * restrictive policy and grant restricted access
+ * to specific applications.
+ * KDBUS_CMD_ENDPOINT_UPDATE: Update the properties of a custom enpoint. Used
+ * to update the policy.
+ *
+ * KDBUS_CMD_HELLO: By opening the bus node, a connection is
+ * created. After a HELLO the opened connection
+ * becomes an active peer on the bus.
+ * KDBUS_CMD_UPDATE: Update the properties of a connection. Used to
+ * update the metadata subscription mask and
+ * policy.
+ * KDBUS_CMD_BYEBYE: Disconnect a connection. If there are no
+ * messages queued up in the connection's pool,
+ * the call succeeds, and the handle is rendered
+ * unusable. Otherwise, -EBUSY is returned without
+ * any further side-effects.
+ * KDBUS_CMD_FREE: Release the allocated memory in the receiver's
+ * pool.
+ * KDBUS_CMD_CONN_INFO: Retrieve credentials and properties of the
+ * initial creator of the connection. The data was
+ * stored at registration time and does not
+ * necessarily represent the connected process or
+ * the actual state of the process.
+ * KDBUS_CMD_BUS_CREATOR_INFO: Retrieve information of the creator of the bus
+ * a connection is attached to.
+ *
+ * KDBUS_CMD_SEND: Send a message and pass data from userspace to
+ * the kernel.
+ * KDBUS_CMD_RECV: Receive a message from the kernel which is
+ * placed in the receiver's pool.
+ *
+ * KDBUS_CMD_NAME_ACQUIRE: Request a well-known bus name to associate with
+ * the connection. Well-known names are used to
+ * address a peer on the bus.
+ * KDBUS_CMD_NAME_RELEASE: Release a well-known name the connection
+ * currently owns.
+ * KDBUS_CMD_LIST: Retrieve the list of all currently registered
+ * well-known and unique names.
+ *
+ * KDBUS_CMD_MATCH_ADD: Install a match which broadcast messages should
+ * be delivered to the connection.
+ * KDBUS_CMD_MATCH_REMOVE: Remove a current match for broadcast messages.
+ */
+enum kdbus_ioctl_type {
+ /* bus owner (00-0f) */
+ KDBUS_CMD_BUS_MAKE = _IOW(KDBUS_IOCTL_MAGIC, 0x00,
+ struct kdbus_cmd),
+
+ /* endpoint owner (10-1f) */
+ KDBUS_CMD_ENDPOINT_MAKE = _IOW(KDBUS_IOCTL_MAGIC, 0x10,
+ struct kdbus_cmd),
+ KDBUS_CMD_ENDPOINT_UPDATE = _IOW(KDBUS_IOCTL_MAGIC, 0x11,
+ struct kdbus_cmd),
+
+ /* connection owner (80-ff) */
+ KDBUS_CMD_HELLO = _IOWR(KDBUS_IOCTL_MAGIC, 0x80,
+ struct kdbus_cmd_hello),
+ KDBUS_CMD_UPDATE = _IOW(KDBUS_IOCTL_MAGIC, 0x81,
+ struct kdbus_cmd),
+ KDBUS_CMD_BYEBYE = _IOW(KDBUS_IOCTL_MAGIC, 0x82,
+ struct kdbus_cmd),
+ KDBUS_CMD_FREE = _IOW(KDBUS_IOCTL_MAGIC, 0x83,
+ struct kdbus_cmd_free),
+ KDBUS_CMD_CONN_INFO = _IOR(KDBUS_IOCTL_MAGIC, 0x84,
+ struct kdbus_cmd_info),
+ KDBUS_CMD_BUS_CREATOR_INFO = _IOR(KDBUS_IOCTL_MAGIC, 0x85,
+ struct kdbus_cmd_info),
+ KDBUS_CMD_LIST = _IOR(KDBUS_IOCTL_MAGIC, 0x86,
+ struct kdbus_cmd_list),
+
+ KDBUS_CMD_SEND = _IOW(KDBUS_IOCTL_MAGIC, 0x90,
+ struct kdbus_cmd_send),
+ KDBUS_CMD_RECV = _IOR(KDBUS_IOCTL_MAGIC, 0x91,
+ struct kdbus_cmd_recv),
+
+ KDBUS_CMD_NAME_ACQUIRE = _IOW(KDBUS_IOCTL_MAGIC, 0xa0,
+ struct kdbus_cmd),
+ KDBUS_CMD_NAME_RELEASE = _IOW(KDBUS_IOCTL_MAGIC, 0xa1,
+ struct kdbus_cmd),
+
+ KDBUS_CMD_MATCH_ADD = _IOW(KDBUS_IOCTL_MAGIC, 0xb0,
+ struct kdbus_cmd_match),
+ KDBUS_CMD_MATCH_REMOVE = _IOW(KDBUS_IOCTL_MAGIC, 0xb1,
+ struct kdbus_cmd_match),
+};
+
+#endif /* _UAPI_KDBUS_H_ */
projects / platform / upstream / dbus.git / commitdiff