From: Adrian Szyndela Date: Fri, 30 Oct 2015 10:19:33 +0000 (+0100) Subject: Add kdbus transport X-Git-Tag: accepted/tizen/common/20160406.143833~10 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=99a9ac73f7edfca32b5dfd2967b9d6087a307db9;p=platform%2Fupstream%2Fdbus.git Add kdbus transport This commit introduces ABI break due to size change of DBusMessageIter structure. Consequently, all packages depending on libdbus need to be rebuilt. Other authors: Paweł Szewczyk Karol Lewandowski and possibly others Change-Id: Ie04b34295c38e5aaac63982996fa9eddc97dd696 --- diff --git a/bus/main.c b/bus/main.c index ee5e1eb..9711c97 100644 --- a/bus/main.c +++ b/bus/main.c @@ -655,6 +655,8 @@ main (int argc, char **argv) _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)); diff --git a/configure.ac b/configure.ac index 7a8e585..f95e830 100644 --- a/configure.ac +++ b/configure.ac @@ -185,6 +185,7 @@ AC_ARG_ENABLE(kqueue, AS_HELP_STRING([--enable-kqueue],[build with kqueue suppor 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])) @@ -1289,8 +1290,24 @@ if test x$with_valgrind != xno; then 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]) + +AC_MSG_CHECKING([whether to enable libdbuspolicy for kdbus transport]) +AM_CONDITIONAL(LIBDBUSPOLICY, [test "x$enable_libdbuspolicy" = "xyes"]) +AS_IF([test "x$enable_libdbuspolicy" = "xyes"], [ + PKG_CHECK_MODULES(LIBDBUSPOLICY1, libdbuspolicy1 >= 1) + AC_SUBST(LIBDBUSPOLICY1_CFLAGS) + AC_SUBST(LIBDBUSPOLICY1_LIBS) + AC_DEFINE(LIBDBUSPOLICY, 1, [Whether to enable libdbuspolicy for kdbus transport]) + AC_MSG_RESULT([yes]) +], [ AC_MSG_RESULT([no]) ]) + #### Set up final flags -LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs $SYSTEMD_LIBS" +LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs $SYSTEMD_LIBS $KDBUS_LIBS" AC_SUBST([LIBDBUS_LIBS]) ### X11 detection @@ -1611,7 +1628,20 @@ AC_DEFINE_UNQUOTED(DBUS_SYSTEM_SOCKET,"$DBUS_SYSTEM_SOCKET",[The name of the soc ## 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 + kdbus_address_path="" + if test x$enable_kdbus_transport = xyes; then + kdbus_address_path="kernel:path=/sys/fs/kdbus/0-system/bus;" + fi + + DBUS_SYSTEM_BUS_DEFAULT_ADDRESS="${kdbus_address_path}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]) @@ -1997,6 +2027,7 @@ echo " Building Ducktype docs: ${enable_ducktype_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} diff --git a/dbus/Makefile.am b/dbus/Makefile.am index d54c261..74446e0 100644 --- a/dbus/Makefile.am +++ b/dbus/Makefile.am @@ -117,6 +117,21 @@ DBUS_SHARED_arch_sources = \ dbus-userdb.h \ $(NULL) +DBUS_SHARED_arch_sources += \ + dbus-marshal-gvariant.c \ + dbus-marshal-gvariant.h \ + dbus-protocol-gvariant.h + +if ENABLE_KDBUS_TRANSPORT +DBUS_SHARED_arch_sources += \ + dbus-transport-kdbus.c \ + dbus-transport-kdbus.h \ + kdbus-common.c \ + kdbus-common.h \ + dbus-signals.c \ + dbus-signals.h +endif + DBUS_UTIL_arch_sources = \ dbus-sysdeps-util-unix.c \ dbus-userdb-util.c \ @@ -235,7 +250,10 @@ DBUS_SHARED_SOURCES= \ $(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 @@ -243,8 +261,6 @@ DBUS_SHARED_SOURCES= \ ### 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 \ diff --git a/dbus/dbus-asv-util.h b/dbus/dbus-asv-util.h index 277ab80..8b6aa44 100644 --- a/dbus/dbus-asv-util.h +++ b/dbus/dbus-asv-util.h @@ -28,13 +28,13 @@ 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, @@ -46,5 +46,4 @@ dbus_bool_t _dbus_asv_add_byte_array (DBusMessageIter *arr_iter, const char *key, const void *value, int n_elements); - #endif diff --git a/dbus/dbus-auth.c b/dbus/dbus-auth.c index f222787..5680ac6 100644 --- a/dbus/dbus-auth.c +++ b/dbus/dbus-auth.c @@ -2353,6 +2353,39 @@ _dbus_auth_client_new (void) } /** + * Creates a new auth conversation object for the client side. + * In fact it only initialize structures and sets authenticated state + * and leaves authentication to different transport-dependent + * mechanisms. + * + * @returns the new object or #NULL if no memory + */ +DBusAuth* +_dbus_auth_client_new_authenticated (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; + + return auth; +} + +/** * Increments the refcount of an auth object. * * @param auth the auth conversation diff --git a/dbus/dbus-auth.h b/dbus/dbus-auth.h index e032302..d10161f 100644 --- a/dbus/dbus-auth.h +++ b/dbus/dbus-auth.h @@ -46,6 +46,8 @@ DBusAuth* _dbus_auth_server_new (const DBusString *guid); DBUS_PRIVATE_EXPORT DBusAuth* _dbus_auth_client_new (void); DBUS_PRIVATE_EXPORT +DBusAuth* _dbus_auth_client_new_authenticated (void); +DBUS_PRIVATE_EXPORT DBusAuth* _dbus_auth_ref (DBusAuth *auth); DBUS_PRIVATE_EXPORT void _dbus_auth_unref (DBusAuth *auth); diff --git a/dbus/dbus-connection-internal.h b/dbus/dbus-connection-internal.h index a58d407..da2db4f 100644 --- a/dbus/dbus-connection-internal.h +++ b/dbus/dbus-connection-internal.h @@ -131,6 +131,7 @@ dbus_bool_t _dbus_connection_putback_message (DBusConnectio DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_connection_remove_message (DBusConnection *connection, DBusMessage *message); +int _dbus_connection_get_n_incoming (DBusConnection *connection); /* if DBUS_ENABLE_STATS */ DBUS_PRIVATE_EXPORT diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c index 64195c7..e6c29fd 100644 --- a/dbus/dbus-connection.c +++ b/dbus/dbus-connection.c @@ -587,8 +587,20 @@ void _dbus_connection_queue_synthesized_message_link (DBusConnection *connection, DBusList *link) { + DBusMessage *msg, *rmsg; + HAVE_LOCK_CHECK (connection); - + + msg = (DBusMessage *)link->data; + + rmsg = msg; + _dbus_transport_assure_protocol_version (connection->transport, &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; @@ -2053,6 +2065,28 @@ _dbus_connection_send_preallocated_unlocked_no_update (DBusConnection *con { 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 converts message if neccessary */ + _dbus_transport_assure_protocol_version (connection->transport, &message); + preallocated->queue_link->data = message; _dbus_list_prepend_link (&connection->outgoing_messages, preallocated->queue_link); @@ -2088,24 +2122,6 @@ _dbus_connection_send_preallocated_unlocked_no_update (DBusConnection *con 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 */ @@ -2237,52 +2253,6 @@ _dbus_memory_pause_based_on_timeout (int timeout_milliseconds) _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 */ @@ -2525,9 +2495,9 @@ _dbus_connection_block_pending_call (DBusPendingCall *pending) { 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); @@ -5335,6 +5305,16 @@ dbus_connection_get_socket(DBusConnection *connection, 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 diff --git a/dbus/dbus-marshal-gvariant.c b/dbus/dbus-marshal-gvariant.c new file mode 100644 index 0000000..a0da345 --- /dev/null +++ b/dbus/dbus-marshal-gvariant.c @@ -0,0 +1,1401 @@ +/* -*- 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 +#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 + +/** 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 */ + size_t 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) +{ + size_t 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) +{ + header->protocol_version = gvariant ? DBUS_PROTOCOL_VERSION_GVARIANT : DBUS_MAJOR_PROTOCOL_VERSION; +} + +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); + size_t 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)); + size_t 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]; + size_t 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 > (size_t)_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 (; (size_t)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); +} + +static int +get_current_type_types_only (const DBusTypeReader *reader) +{ + int t; + if (reader->finished) + t = DBUS_TYPE_INVALID; + else + t = _dbus_first_type_in_signature (reader->type_str, + reader->type_pos); + + return t; +} + +/* 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 = get_current_type_types_only (&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); + size_t 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; + size_t 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); +} diff --git a/dbus/dbus-marshal-gvariant.h b/dbus/dbus-marshal-gvariant.h new file mode 100644 index 0000000..79d23a0 --- /dev/null +++ b/dbus/dbus-marshal-gvariant.h @@ -0,0 +1,132 @@ +/* -*- 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 +#include +#include +#include + +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 */ diff --git a/dbus/dbus-marshal-header.c b/dbus/dbus-marshal-header.c index 48151c6..bd98a12 100644 --- a/dbus/dbus-marshal-header.c +++ b/dbus/dbus-marshal-header.c @@ -27,6 +27,9 @@ #include "dbus-marshal-recursive.h" #include "dbus-marshal-byteswap.h" +#include "dbus-protocol-gvariant.h" +#include "dbus-marshal-gvariant.h" + /** * @addtogroup DBusMarshal * @@ -123,6 +126,12 @@ correct_header_padding (DBusHeader *header) #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 @@ -415,6 +424,11 @@ _dbus_header_set_serial (DBusHeader *header, 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)); } /** @@ -513,6 +527,7 @@ _dbus_header_copy (const DBusHeader *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 @@ -678,13 +693,16 @@ _dbus_header_have_message_untrusted (int max_message_length, 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); @@ -699,9 +717,32 @@ _dbus_header_have_message_untrusted (int max_message_length, 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) { @@ -709,10 +750,6 @@ _dbus_header_have_message_untrusted (int 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; @@ -940,6 +977,86 @@ load_and_validate_field (DBusHeader *header, 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 @@ -981,13 +1098,11 @@ _dbus_header_load (DBusHeader *header, 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); @@ -999,6 +1114,14 @@ _dbus_header_load (DBusHeader *header, *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) { @@ -1006,10 +1129,20 @@ _dbus_header_load (DBusHeader *header, } 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) { @@ -1048,7 +1181,7 @@ _dbus_header_load (DBusHeader *header, _dbus_type_reader_init (&reader, byte_order, - &_dbus_header_signature_str, 0, + signature, 0, str, start); /* BYTE ORDER */ @@ -1090,75 +1223,25 @@ _dbus_header_load (DBusHeader *header, 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 */ @@ -1258,19 +1341,8 @@ find_field_for_modification (DBusHeader *header, 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) @@ -1338,17 +1410,29 @@ _dbus_header_set_field_basic (DBusHeader *header, } /** - * 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) @@ -1374,6 +1458,26 @@ _dbus_header_get_field_basic (DBusHeader *header, 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 diff --git a/dbus/dbus-marshal-header.h b/dbus/dbus-marshal-header.h index c8c0112..0073e4f 100644 --- a/dbus/dbus-marshal-header.h +++ b/dbus/dbus-marshal-header.h @@ -57,6 +57,7 @@ struct DBusHeader 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); @@ -111,7 +112,8 @@ dbus_bool_t _dbus_header_have_message_untrusted (int max_messag 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, diff --git a/dbus/dbus-marshal-recursive.c b/dbus/dbus-marshal-recursive.c index 9ba16e9..ee3fa98 100644 --- a/dbus/dbus-marshal-recursive.c +++ b/dbus/dbus-marshal-recursive.c @@ -2,6 +2,7 @@ /* 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 * @@ -26,6 +27,7 @@ #include "dbus-marshal-basic.h" #include "dbus-signature.h" #include "dbus-internals.h" +#include "dbus-marshal-gvariant.h" /** * @addtogroup DBusMarshal @@ -147,7 +149,8 @@ reader_init (DBusTypeReader *reader, const DBusString *type_str, int type_pos, const DBusString *value_str, - int value_pos) + int value_pos, + dbus_bool_t gvariant) { _DBUS_ZERO (*reader); reader->byte_order = byte_order; @@ -156,6 +159,11 @@ reader_init (DBusTypeReader *reader, 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 @@ -168,7 +176,8 @@ base_reader_recurse (DBusTypeReader *sub, parent->type_str, parent->type_pos, parent->value_str, - parent->value_pos); + parent->value_pos, + parent->gvariant); } static void @@ -191,8 +200,31 @@ struct_or_dict_entry_reader_recurse (DBusTypeReader *sub, { 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 @@ -220,6 +252,9 @@ array_reader_get_array_len (const DBusTypeReader *reader) 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); @@ -245,20 +280,38 @@ array_reader_recurse (DBusTypeReader *sub, 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", @@ -280,21 +333,46 @@ variant_reader_recurse (DBusTypeReader *sub, 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", @@ -339,7 +417,7 @@ skip_one_complete_type (const DBusString *type_str, */ void _dbus_type_signature_next (const char *type_str, - int *type_pos) + int *type_pos) { const unsigned char *p; const unsigned char *start; @@ -444,6 +522,7 @@ base_reader_next (DBusTypeReader *reader, case DBUS_TYPE_STRUCT: case DBUS_TYPE_VARIANT: /* Scan forward over the entire container contents */ + /* FIXME for GVariant - use offsets */ { DBusTypeReader sub; @@ -490,7 +569,8 @@ base_reader_next (DBusTypeReader *reader, 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); @@ -500,12 +580,40 @@ base_reader_next (DBusTypeReader *reader, } 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. @@ -521,12 +629,22 @@ struct_reader_next (DBusTypeReader *reader, } 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. @@ -560,6 +678,26 @@ array_reader_next (DBusTypeReader *reader, /* 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 @@ -632,12 +770,33 @@ array_reader_next (DBusTypeReader *reader, } } +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 = { @@ -645,7 +804,7 @@ 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 = { @@ -701,7 +860,7 @@ static const DBusTypeReaderClass variant_reader_class = { FALSE, variant_reader_recurse, NULL, - base_reader_next + variant_reader_next }; #ifndef DBUS_DISABLE_ASSERT @@ -738,7 +897,7 @@ _dbus_type_reader_init (DBusTypeReader *reader, int value_pos) { reader_init (reader, byte_order, type_str, type_pos, - value_str, value_pos); + value_str, value_pos, FALSE); reader->klass = &body_reader_class; @@ -763,7 +922,8 @@ _dbus_type_reader_init_types_only (DBusTypeReader *reader, int type_pos) { 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); reader->klass = &body_types_only_reader_class; @@ -876,7 +1036,8 @@ _dbus_type_reader_read_basic (const DBusTypeReader *reader, 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, @@ -1502,9 +1663,14 @@ _dbus_type_writer_init (DBusTypeWriter *writer, 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, @@ -1534,6 +1700,24 @@ _dbus_type_writer_init_types_delayed (DBusTypeWriter *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. * @@ -1601,12 +1785,19 @@ _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer, 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; } @@ -1645,6 +1836,7 @@ writer_recurse_init_and_check (DBusTypeWriter *writer, 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)) @@ -1795,12 +1987,28 @@ writer_recurse_struct_or_dict_entry (DBusTypeWriter *writer, 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; @@ -1888,27 +2096,47 @@ writer_recurse_array (DBusTypeWriter *writer, 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) @@ -1927,7 +2155,7 @@ writer_recurse_array (DBusTypeWriter *writer, sub->u.array.start_pos = sub->value_pos; - if (is_array_append) + if (is_array_append && !writer->gvariant) { dbus_uint32_t len; @@ -1940,6 +2168,12 @@ writer_recurse_array (DBusTypeWriter *writer, sub->value_pos += len; } + if (writer->gvariant) + { + sub->alignment = alignment; + sub->is_fixed = FALSE; + sub->value_start = sub->value_pos; + } } else { @@ -1948,7 +2182,7 @@ writer_recurse_array (DBusTypeWriter *writer, 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 @@ -2015,31 +2249,58 @@ writer_recurse_variant (DBusTypeWriter *writer, /* 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, @@ -2047,6 +2308,7 @@ writer_recurse_variant (DBusTypeWriter *writer, '\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; } @@ -2119,6 +2381,8 @@ _dbus_type_writer_recurse (DBusTypeWriter *writer, else contained_type_len = 0; + sub->body_container = FALSE; + return _dbus_type_writer_recurse_contained_len (writer, container_type, contained_type, contained_type_start, @@ -2167,32 +2431,10 @@ writer_get_array_len (DBusTypeWriter *writer) 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)) @@ -2203,7 +2445,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, 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 */ { @@ -2227,6 +2469,46 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, } #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: * @@ -2286,8 +2568,6 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, } } - 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, diff --git a/dbus/dbus-marshal-recursive.h b/dbus/dbus-marshal-recursive.h index fa1d1ef..aa9e513 100644 --- a/dbus/dbus-marshal-recursive.h +++ b/dbus/dbus-marshal-recursive.h @@ -2,6 +2,7 @@ /* 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 * @@ -44,10 +45,17 @@ struct DBusTypeReader * 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 @@ -71,10 +79,18 @@ struct DBusTypeWriter 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 { @@ -83,6 +99,9 @@ struct DBusTypeWriter 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 */ }; @@ -158,6 +177,11 @@ void _dbus_type_writer_init_types_delayed (DBusTypeWriter *write 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); @@ -174,6 +198,12 @@ dbus_bool_t _dbus_type_writer_write_basic (DBusTypeWriter *write int type, const void *value); DBUS_PRIVATE_EXPORT +dbus_bool_t _dbus_type_writer_write_basic_with_gvariant + (DBusTypeWriter *writer, + int type, + const void *value, + dbus_bool_t gvariant); +DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer, int element_type, const void *value, diff --git a/dbus/dbus-message-internal.h b/dbus/dbus-message-internal.h index 4bb4d8b..fbb19d3 100644 --- a/dbus/dbus-message-internal.h +++ b/dbus/dbus-message-internal.h @@ -112,11 +112,23 @@ int _dbus_message_loader_get_pending_fds_count (DBusMessageLoader void _dbus_message_loader_set_pending_fds_function (DBusMessageLoader *loader, void (* callback) (void *), void *data); +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_bool_t _dbus_message_assure_dbus1 (DBusMessage **message); +dbus_bool_t _dbus_message_assure_gvariant (DBusMessage **message); + DBUS_END_DECLS #endif /* DBUS_MESSAGE_INTERNAL_H */ diff --git a/dbus/dbus-message-private.h b/dbus/dbus-message-private.h index 50c41a8..75076c4 100644 --- a/dbus/dbus-message-private.h +++ b/dbus/dbus-message-private.h @@ -83,6 +83,7 @@ struct DBusMessageLoader void (* unix_fds_change) (void *); /**< Notify when the pending fds change */ void *unix_fds_change_data; #endif + uint64_t unique_sender_id; }; @@ -131,6 +132,8 @@ struct DBusMessage 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_PRIVATE_EXPORT diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 699e022..d0c312d 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -3,6 +3,7 @@ * * 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 * @@ -38,6 +39,8 @@ #include "dbus-sysdeps.h" #include "dbus-sysdeps-unix.h" #endif +#include "dbus-marshal-gvariant.h" +#include "dbus-protocol-gvariant.h" #include @@ -45,6 +48,8 @@ (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); /** @@ -118,6 +123,8 @@ enum { /** 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 * @@ -136,19 +143,80 @@ struct DBusMessageRealIter } 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 +_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 (DBusHeader *header, +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; @@ -174,7 +242,7 @@ _dbus_message_byteswap (DBusMessage *message) _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, @@ -385,8 +453,11 @@ dbus_message_lock (DBusMessage *message) { 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 || @@ -666,6 +737,18 @@ dbus_message_cache_or_finalize (DBusMessage *message) 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)) @@ -1143,13 +1226,25 @@ dbus_bool_t 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)) + { + dbus_uint64_t reply_serial_uint64 = reply_serial; + type = DBUS_TYPE_UINT64; + return _dbus_header_set_field_basic (&message->header, + DBUS_HEADER_FIELD_REPLY_SERIAL, + type, + &reply_serial_uint64); + } + return _dbus_header_set_field_basic (&message->header, DBUS_HEADER_FIELD_REPLY_SERIAL, - DBUS_TYPE_UINT32, + type, &reply_serial); } @@ -1163,14 +1258,28 @@ dbus_uint32_t 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; } @@ -1201,7 +1310,7 @@ dbus_message_finalize (DBusMessage *message) } static DBusMessage* -dbus_message_new_empty_header (void) +dbus_message_new_empty_header (dbus_bool_t gvariant) { DBusMessage *message; dbus_bool_t from_cache; @@ -1246,6 +1355,8 @@ dbus_message_new_empty_header (void) 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); @@ -1270,36 +1381,33 @@ dbus_message_new_empty_header (void) } } + 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; @@ -1308,6 +1416,42 @@ dbus_message_new (int message_type) 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 @@ -1335,8 +1479,6 @@ dbus_message_new_method_call (const char *destination, 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 || @@ -1346,20 +1488,8 @@ dbus_message_new_method_call (const char *destination, _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); } /** @@ -1381,19 +1511,11 @@ dbus_message_new_method_return (DBusMessage *method_call) /* 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, @@ -1434,19 +1556,11 @@ dbus_message_new_signal (const char *path, _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; @@ -1485,19 +1599,11 @@ dbus_message_new_error (DBusMessage *reply_to, * 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, @@ -1600,6 +1706,7 @@ dbus_message_copy (const DBusMessage *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)) { @@ -2068,19 +2175,24 @@ dbus_message_iter_init (DBusMessage *message, 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; } @@ -2469,10 +2581,12 @@ dbus_message_iter_init_append (DBusMessage *message, * 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)); } /** @@ -2511,11 +2625,21 @@ _dbus_message_iter_open_signature (DBusMessageRealIter *real) 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; @@ -3549,6 +3673,9 @@ dbus_message_get_sender (DBusMessage *message) _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, @@ -3583,7 +3710,7 @@ dbus_message_get_signature (DBusMessage *message) _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); } @@ -4187,18 +4314,33 @@ load_message (DBusMessageLoader *loader, /* 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); @@ -4320,6 +4462,31 @@ load_message (DBusMessageLoader *loader, 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. @@ -4342,6 +4509,7 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) { 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, @@ -4350,13 +4518,14 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) &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; @@ -4371,6 +4540,12 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) 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); } @@ -4575,6 +4750,19 @@ _dbus_message_loader_set_pending_fds_function (DBusMessageLoader *loader, #endif } +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)); @@ -4884,6 +5072,7 @@ dbus_message_demarshal_bytes_needed(const char *buf, 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; @@ -4900,7 +5089,8 @@ dbus_message_demarshal_bytes_needed(const char *buf, &header_len, &body_len, &str, 0, - len); + len, + &is_gvariant); _dbus_string_free (&str); if (validity == DBUS_VALID) @@ -4963,6 +5153,224 @@ dbus_message_get_allow_interactive_authorization (DBusMessage *message) DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION); } +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; +} + +dbus_bool_t +_dbus_message_assure_dbus1 (DBusMessage **message) +{ + if ((*message)->header.protocol_version != DBUS_MAJOR_PROTOCOL_VERSION) + { + *message = _dbus_message_remarshal (*message, FALSE); + } + return *message != NULL; +} + +dbus_bool_t +_dbus_message_assure_gvariant (DBusMessage **message) +{ + if ((*message)->header.protocol_version != DBUS_PROTOCOL_VERSION_GVARIANT) + { + *message = _dbus_message_remarshal (*message, TRUE); + } + return *message != NULL; +} + /** @} */ /* tests in dbus-message-util.c */ diff --git a/dbus/dbus-message.h b/dbus/dbus-message.h index 3e33eb7..07ca06c 100644 --- a/dbus/dbus-message.h +++ b/dbus/dbus-message.h @@ -2,6 +2,7 @@ /* 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 * @@ -49,21 +50,72 @@ typedef struct DBusMessageIter DBusMessageIter; * 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 dummy3a : 21; /**< Don't use this */ + dbus_uint32_t dummy3b : 3; /**< Don't use this */ + dbus_uint32_t dummy3c : 8; /**< Don't use this */ + + /* padding before union */ + union { + struct + { + dbus_uint32_t dummy1a : 8; /**< Don't use this */ + dbus_uint32_t dummy1b : 1; /**< Don't use this */ + dbus_uint32_t dummy1c : 3; /**< Don't use this */ + dbus_uint32_t dummy1d : 1; /**< Don't use this */ + dbus_uint32_t dummy1e : 1; /**< Don't use this */ + dbus_uint32_t dummy1f : 1; /**< Don't use this */ + void *dummy2; /**< Don't use this */ + int dummy3; /**< Don't use this */ + void *dummy4; /**< Don't use this */ + int dummy5; /**< Don't use this */ + int dummy6; /**< Don't use this */ + size_t dummy7; /**< Don't use this */ + size_t dummy8; /**< Don't use this */ + int dummy9; /**< Don't use this */ + + void *dummy10; /**< Don't use this */ + union + { + struct { + int dummy11; /**< Don't use this */ + }; + } u; + } s1; + + struct + { + dbus_uint32_t dummy1a : 8; /**< Don't use this */ + dbus_uint32_t dummy1b : 8; /**< Don't use this */ + dbus_uint32_t dummy1c : 1; /**< Don't use this */ + dbus_uint32_t dummy1d : 1; /**< Don't use this */ + dbus_uint32_t dummy1e : 1; /**< Don't use this */ + dbus_uint32_t dummy1f : 1; /**< Don't use this */ + dbus_uint32_t dummy1g : 1; /**< Don't use this */ + + void *dummy2; /**< Don't use this */ + int dummy3; /**< Don't use this */ + void *dummy4; /**< Don't use this */ + int dummy5; /**< Don't use this */ + size_t dummy6; /**< Don't use this */ + void *dummy7; /**< Don't use this */ + int dummy8; /**< Don't use this */ + char dummy9; /**< Don't use this */ + + union + { + struct { + int dummy10; /**< Don't use this */ + int dummy11; /**< Don't use this */ + int dummy12; /**< Don't use this */ + }; + struct { + size_t dummy13; /**< Don't use this */ + }; + } u; + } s2; + } u; }; DBUS_EXPORT @@ -313,6 +365,9 @@ DBUS_EXPORT dbus_bool_t dbus_message_get_allow_interactive_authorization ( DBusMessage *message); +DBUS_EXPORT +void dbus_set_protocol_version (unsigned char version); + /** @} */ DBUS_END_DECLS diff --git a/dbus/dbus-pending-call.c b/dbus/dbus-pending-call.c index be53410..ed96242 100644 --- a/dbus/dbus-pending-call.c +++ b/dbus/dbus-pending-call.c @@ -367,6 +367,9 @@ _dbus_pending_call_set_timeout_error_unlocked (DBusPendingCall *pending, if (reply == NULL) return FALSE; + /* FIXME - lock may now fail */ + dbus_message_lock (reply); + reply_link = _dbus_list_alloc_link (reply); if (reply_link == NULL) { diff --git a/dbus/dbus-protocol-gvariant.h b/dbus/dbus-protocol-gvariant.h new file mode 100644 index 0000000..c01f923 --- /dev/null +++ b/dbus/dbus-protocol-gvariant.h @@ -0,0 +1,56 @@ +/* -*- 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 */ diff --git a/dbus/dbus-shared.h b/dbus/dbus-shared.h index e5bfbed..1ef1e57 100644 --- a/dbus/dbus-shared.h +++ b/dbus/dbus-shared.h @@ -125,6 +125,8 @@ typedef enum #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 diff --git a/dbus/dbus-signals.c b/dbus/dbus-signals.c new file mode 100644 index 0000000..e0496b1 --- /dev/null +++ b/dbus/dbus-signals.c @@ -0,0 +1,1633 @@ +/* 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 +#include "dbus-internals.h" +#include "dbus-hash.h" +#include "dbus-list.h" +#include "kdbus-common.h" +#include +#include + +#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 : ""); + + 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 : ""); + + 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 : ""); + + 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); + } + } +} + +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]; +} diff --git a/dbus/dbus-signals.h b/dbus/dbus-signals.h new file mode 100644 index 0000000..da3fd57 --- /dev/null +++ b/dbus/dbus-signals.h @@ -0,0 +1,117 @@ +/* + * 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 +#include +#include +#include + +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_ */ diff --git a/dbus/dbus-transport-kdbus.c b/dbus/dbus-transport-kdbus.c new file mode 100644 index 0000000..87a085b --- /dev/null +++ b/dbus/dbus-transport-kdbus.c @@ -0,0 +1,4000 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0) +# if defined(__arm__) || defined(__aarch64__) +# define __NR_memfd_create 385 +# elif defined(__i386__) +# define __NR_memfd_create 279 +# else +# error "Architecture not supported" +# endif +#else +# include +#endif + +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 + +#ifndef MFD_CLOEXEC +#define MFD_CLOEXEC 0x0001U +#endif + +#ifndef MFD_ALLOW_SEALING +#define MFD_ALLOW_SEALING 0x0002U +#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 */ + kdbus_t *kdbus; + 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. */ + + char* my_DBus_unique_name; /**< unique name in DBus string format - :1.x , where x is kdbus id*/ + char* activator; /**< well known name for activator */ + Matchmaker *matchmaker; /**< for match rules management */ + dbus_uint32_t client_serial; /**< serial number for messages synthesized by library*/ +}; + +static kdbus_t * +get_kdbus (DBusTransport *transport) +{ + return ((DBusTransportKdbus*)transport)->kdbus; +} + +/** + * 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; +} + +/* + * 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; + 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 +send_message (DBusTransportKdbus *transport, + struct kdbus_msg *kdbus_msg, + dbus_bool_t sync, + const char *destination, + dbus_bool_t is_auto_start, + struct kdbus_msg **kdbus_msg_reply, + DBusError *error) +{ + int ret; + dbus_uint64_t flags = 0; + + if (sync) + flags |= KDBUS_SEND_SYNC_REPLY; + + ret = _kdbus_send (transport->kdbus, + flags, + kdbus_msg, + kdbus_msg_reply); + if (ret != 0) + { + _dbus_verbose ("kdbus error sending message: err %d (%s)\n", ret, _dbus_strerror (ret) ); + + switch (ret) + { + 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", + destination); + break; + + case EADDRNOTAVAIL: + case ECONNRESET: + /* when well known name is not available on the bus */ + if (is_auto_start) + dbus_set_error (error, + DBUS_ERROR_SERVICE_UNKNOWN, + "The name %s was not provided by any .service files", + destination); + else + dbus_set_error (error, + DBUS_ERROR_NAME_HAS_NO_OWNER, + "Name \"%s\" does not exist", + destination); + 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", + destination); + break; + + default: + break; + } + + ret = -1; + } + return ret; +} + +static void +kdbus_close_message (DBusTransportKdbus *transport, struct kdbus_msg *msg) +{ + struct kdbus_item *item; + + KDBUS_ITEM_FOREACH (item, msg, items) + { + if (item->type == KDBUS_ITEM_PAYLOAD_MEMFD) + close (item->memfd.fd); + } + + _kdbus_free_mem (transport->kdbus, msg); +} + +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_msg *msg = NULL; + struct kdbus_msg *msg_reply = 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_uint64_t items_size; + dbus_uint64_t flags = 0; + dbus_uint64_t timeout_ns_or_cookie_reply = 0; + + 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 valid: %s\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); + + items_size = _kdbus_compute_msg_items_size (transport->kdbus, + destination, + dst_id, + body_size, + memfd >= 0, + fds_count); + + if (!dbus_message_get_auto_start (message)) + flags |= KDBUS_MSG_NO_AUTO_START; + + if (KDBUS_DST_ID_BROADCAST == dst_id) /* signals */ + flags |= KDBUS_MSG_SIGNAL; + else + { + if (dbus_message_get_no_reply (message)) /* method replies and errors */ + timeout_ns_or_cookie_reply = dbus_message_get_reply_serial (message); + else /* method calls */ + { + long tv_sec, tv_usec; + + _dbus_get_monotonic_time (&tv_sec, &tv_usec); + /* ms us ns */ + timeout_ns_or_cookie_reply = (dbus_uint64_t)tv_sec * 1000ULL * 1000ULL * 1000ULL + + tv_usec * 1000ULL + + KDBUS_DEFAULT_TIMEOUT_NS; + + flags |= KDBUS_MSG_EXPECT_REPLY; + } + } + + msg = _kdbus_new_msg (transport->kdbus, + items_size, + flags, + 0, + dst_id, + 0, + KDBUS_PAYLOAD_DBUS, + dbus_message_get_serial (message), + timeout_ns_or_cookie_reply); + if (NULL == msg) + return -1; + + /* 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 = _kdbus_item_add_payload_memfd (item, + 0, + ret_size, + memfd); + } + else + { + const char* header_data = _dbus_string_get_const_data (header); + + _dbus_verbose ("sending data by vec\n"); + item = _kdbus_item_add_payload_vec (item, + header_size, + (dbus_uint64_t)header_data); + if (body_size > 0) + { + const char* 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 > 0) + { + dbus_uint64_t part_size = body_size; + + if (part_size > KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE) + part_size = KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE; + + _dbus_verbose ("attaching body part\n"); + item = _kdbus_item_add_payload_vec (item, + part_size, + (dbus_uint64_t)body_data); + body_data += part_size; + body_size -= part_size; + } + } + } + + if (fds_count) + item = _kdbus_item_add_fds (item, unix_fds, fds_count); + + if (NULL != destination) + item = _kdbus_item_add_string (item, + KDBUS_ITEM_DST_NAME, + destination, + strlen (destination) + 1); + else if (dst_id == KDBUS_DST_ID_BROADCAST) + { + struct kdbus_bloom_parameter *bloom = _kdbus_bloom (transport->kdbus); + struct kdbus_bloom_filter *filter = NULL; + item = _kdbus_item_add_bloom_filter (item, + bloom->size, + &filter); + bus_message_setup_bloom (message, filter, bloom); + } + + if (send_message (transport, + msg, + check_sync_reply, + dbus_message_get_destination (message), + dbus_message_get_auto_start (message), + &msg_reply, + &error) != 0) + { + int ret = -1; + if (dbus_error_is_set (&error)) + ret = reply_with_error (error.name, + NULL, + error.message, + message, + transport->base.connection); + if (-1 == ret) + ret_size = -1; + } + + if (check_sync_reply) + kdbus_close_message (transport, msg_reply); + + out: + if (msg) + _kdbus_free_msg (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); +} + +static dbus_uint64_t +get_pool_size (void) +{ + dbus_uint64_t receive_pool_size = RECEIVE_POOL_SIZE_DEFAULT_SIZE; + const char *env_pool; + + env_pool = _dbus_getenv (RECEIVE_POOL_SIZE_ENV_VAR_NAME); + if (env_pool) + { + dbus_uint64_t size = 0; + unsigned int multiply = 1; + long int page_size; + + page_size = sysconf (_SC_PAGESIZE); + if (page_size == -1) + { + 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", (unsigned long long)receive_pool_size); + return receive_pool_size; +} + +/** + * 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) +{ + int ret; + dbus_uint64_t flags; + + flags = KDBUS_HELLO_ACCEPT_FD; + if (registration_flags & REGISTER_FLAG_MONITOR) + flags |= KDBUS_HELLO_MONITOR; + + ret = _kdbus_hello (transport->kdbus, + flags, + _KDBUS_ATTACH_ANY, + 0, + get_pool_size (), + transport->activator, + "libdbus-kdbus"); + if (ret != 0) + { + dbus_set_error (error, DBUS_ERROR_FAILED, "Hello failed: %d", -ret); + return FALSE; + } + + transport->my_DBus_unique_name = create_unique_name_from_unique_id (_kdbus_id (transport->kdbus)); + if (NULL == transport->my_DBus_unique_name) + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, "Hello post failed: %d", -ret); + return FALSE; + } + + _dbus_verbose ("-- Our peer ID is: %llu\n", (unsigned long long)_kdbus_id (transport->kdbus)); + + 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; +} + +static int +strcmp_existing (const char *str1, const char *str2) +{ + if (NULL == str1 || NULL == str2) + return 0; + return strcmp (str1, str2); +} + +static dbus_bool_t +kernel_match_needed (MatchRule *rule) +{ + int message_type; + + /* Allow only NameOwnerChanged member */ + if (strcmp_existing (_match_rule_get_member (rule), "NameOwnerChanged") != 0) + return FALSE; + + /* Allow only signals */ + message_type = _match_rule_get_message_type (rule); + if (message_type != DBUS_MESSAGE_TYPE_INVALID && message_type != DBUS_MESSAGE_TYPE_SIGNAL) + return FALSE; + + /* Check if from DBus */ + if (strcmp_existing (_match_rule_get_sender (rule), DBUS_SERVICE_DBUS) != 0) + return FALSE; + + if (strcmp_existing (_match_rule_get_interface (rule), DBUS_INTERFACE_DBUS) != 0) + return FALSE; + + if (strcmp_existing (_match_rule_get_path (rule), DBUS_PATH_DBUS) != 0) + return FALSE; + + return TRUE; +} + +static dbus_bool_t +is_bloom_needed (MatchRule *rule) +{ + int rule_int; + int i; + + if (_match_rule_get_message_type (rule) != DBUS_TYPE_INVALID + || _match_rule_get_interface (rule) != NULL + || _match_rule_get_member (rule) != NULL + || _match_rule_get_path (rule) != NULL + || _match_rule_get_path_namespace (rule) != NULL) + return TRUE; + + rule_int = _match_rule_get_args_len (rule); + for (i = 0; i < rule_int; i++) + { + if (_match_rule_get_args (rule, i) != NULL) + return TRUE; + } + + return FALSE; +} + +static dbus_uint64_t * +get_bloom (kdbus_t *kdbus, MatchRule *rule) +{ + dbus_uint64_t *bloom; + dbus_uint64_t bloom_size; + int rule_int; + const char *rule_string; + int i; + char argument_buf[sizeof ("arg")-1 + 2 + sizeof ("-slash-prefix") +1]; + + bloom_size = _kdbus_bloom (kdbus)->size; + bloom = dbus_malloc (bloom_size); + if (bloom == NULL) + return NULL; + + memset (bloom, 0, bloom_size); + + rule_int = _match_rule_get_message_type (rule); + if (rule_int != DBUS_MESSAGE_TYPE_INVALID) + { + bloom_add_pair (bloom, _kdbus_bloom (kdbus), "message-type", dbus_message_type_to_string (rule_int)); + _dbus_verbose ("Adding type %s \n", dbus_message_type_to_string (rule_int)); + } + + rule_string = _match_rule_get_interface (rule); + if (rule_string != NULL) + { + bloom_add_pair (bloom, _kdbus_bloom (kdbus), "interface", rule_string); + _dbus_verbose ("Adding interface %s \n", rule_string); + } + + rule_string = _match_rule_get_member (rule); + if (rule_string != NULL) + { + bloom_add_pair (bloom, _kdbus_bloom (kdbus), "member", rule_string); + _dbus_verbose ("Adding member %s \n", rule_string); + } + + rule_string = _match_rule_get_path (rule); + if (rule_string != NULL) + { + bloom_add_pair (bloom, _kdbus_bloom (kdbus), "path", rule_string); + _dbus_verbose ("Adding path %s \n", rule_string); + } + + rule_string = _match_rule_get_path_namespace (rule); + if (rule_string != NULL) + { + bloom_add_pair (bloom, _kdbus_bloom (kdbus), "path-slash-prefix", rule_string); + _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, _kdbus_bloom (kdbus), argument_buf, rule_string, '/'); + } + else if (rule_arg_lens & MATCH_ARG_NAMESPACE) + { + sprintf (argument_buf, "arg%d-dot-prefix", i); + bloom_add_prefixes (bloom, _kdbus_bloom (kdbus), argument_buf, rule_string, '.'); + } + else + { + sprintf (argument_buf, "arg%d", i); + bloom_add_pair (bloom, _kdbus_bloom (kdbus), argument_buf, rule_string); + } + } + } + + return bloom; +} + +/** + * 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 *cmd; + struct kdbus_item *item; + int sender = -1; + int sender_size = 0; + __u64 bloom_size; + __u64 rule_cookie; + uint64_t src_id = KDBUS_MATCH_ID_ANY; + uint64_t items_size; + uint64_t *bloom; + dbus_bool_t need_bloom = FALSE; + + const char *rule_sender; + int ret; + + 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). + */ + if (kernel_match_needed (rule)) + { + ret = _kdbus_add_match_name_change (transport->kdbus, + 0, + rule_cookie, + KDBUS_MATCH_ID_ANY, + 0, + KDBUS_MATCH_ID_ANY, + 0); + if (0 != ret) + { + _dbus_verbose ("Failed adding match rule for name removal for daemon, error: %d, %s\n", + ret, _dbus_strerror (ret)); + return FALSE; + } + + ret = _kdbus_add_match_id_change (transport->kdbus, + 0, + rule_cookie, + KDBUS_MATCH_ID_ANY, + 0); + if (0 != ret) + { + _dbus_verbose ("Failed adding match rule for adding id for daemon, error: %d, %s\n", + ret, _dbus_strerror (ret)); + return FALSE; + } + + _dbus_verbose ("Added match rule for kernel correctly.\n"); + +/* + * In case all of sender, interface and path are NULL, the rule + * says simply about NameHasOwner signal from any object, any interface, any sender. + * So, we need to consider that. + * Otherwise, our job is finished here. + */ + if (_match_rule_get_sender (rule) != NULL + || _match_rule_get_interface (rule) != NULL + || _match_rule_get_path (rule) != NULL) + return TRUE; + } + +/* + * standard rule - registered in general way, for non-kernel broadcasts + * kdbus doesn't use it to check kdbus (kernel) generated broadcasts + */ + + items_size = 0; + + need_bloom = is_bloom_needed (rule); + if (need_bloom) + { + bloom_size = _kdbus_bloom (transport->kdbus)->size; + items_size += KDBUS_ITEM_SIZE (bloom_size); + bloom = get_bloom (transport->kdbus, rule); + if (NULL == bloom) + return FALSE; + } + + rule_sender = _match_rule_get_sender (rule); + if (rule_sender != NULL) + { + sender = parse_name (rule_sender, &src_id); + if (sender < 0) + return FALSE; + + if (sender > 0) /* unique_id */ + items_size += KDBUS_ITEM_SIZE (sizeof (uint64_t)); + else /* well-known name */ + { + sender_size = strlen (rule_sender) + 1; + items_size += KDBUS_ITEM_SIZE (sender_size); + } + } + + cmd = _kdbus_new_cmd_match (transport->kdbus, + items_size, + 0, + rule_cookie); + if (NULL == cmd) + ret = ENOMEM; + else + { + item = cmd->items; + if (0 == sender) /* well-known name */ + { + item = _kdbus_item_add_string (item, + KDBUS_ITEM_NAME, + rule_sender, + sender_size); + _dbus_verbose ("Adding sender %s \n", rule_sender); + } + else if (KDBUS_MATCH_ID_ANY != src_id) /* unique id */ + { + item = _kdbus_item_add_id (item, src_id); + _dbus_verbose ("Adding src_id %llu \n", (unsigned long long)src_id); + } + + if (need_bloom) + { + item = _kdbus_item_add_bloom_mask (item, bloom, bloom_size); + dbus_free (bloom); + } + + ret = _kdbus_add_match (transport->kdbus, cmd); + + _kdbus_free_cmd_match (cmd); + } + + if (0 != ret) + { + _dbus_verbose ("Failed adding match bus rule cookie %llu,\nerror: %d, %s\n", + rule_cookie, ret, _dbus_strerror (ret)); + 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_connection_info_by_name (get_kdbus (transport), name, getLabel, 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 (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_byte_array (&array_iter, "LinuxSecurityLabel", + info.sec_label, + strlen (info.sec_label)+1); + + dbus_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); + + dbus_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) +{ + dbus_uint64_t bus_id_size = _kdbus_bus_id_size (); + char bus_id[bus_id_size*2+1]; + char *bus_id_ptr = bus_id; + char *bus_id_original = _kdbus_bus_id (transport->kdbus); + int i = 0; + for (; i < bus_id_size; i++) + sprintf (bus_id + 2*i, "%02x", bus_id_original[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; + dbus_uint64_t list_size; + int ret; + DBusMessageIter iter; + DBusMessageIter array_iter; + + ret = _kdbus_list (transport->kdbus, + flags, + &name_list, + &list_size); + 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; + + KDBUS_FOREACH (name, name_list, 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_free_mem (transport->kdbus, name_list); + 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 = 0; + dbus_bool_t dbus_service = FALSE; + + if (!dbus_message_get_args (message, error, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID)) + return -1; + + dbus_service = (strncmp (name, DBUS_SERVICE_DBUS, strlen (DBUS_SERVICE_DBUS) + 1) == 0); + + if (!dbus_service) + ret = get_connection_info_by_name (message, + error, + &info, + &transport->base, + name, + FALSE); + + if (dbus_service || 0 == ret) + { + 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 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); + + dbus_message_lock (sub_message); + + 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 + { + /* + * There was an error set in get_connection_info_by_name() + * We want to have another error return from StartServiceByName. + */ + dbus_error_free (error); + 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_id (kdbus_transport->kdbus)) + ret_size = generate_NameSignal ("NameAcquired", item->name_change.name, kdbus_transport); + else if (item->name_change.old_id.id == _kdbus_id (kdbus_transport->kdbus)) + 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_msg *msg; + char *data; + int start; + dbus_uint64_t flags = 0; + int ret; + + start = _dbus_string_get_length (buffer); + + if (kdbus_transport->activator != NULL) + flags |= KDBUS_RECV_PEEK; + + ret = _kdbus_recv (kdbus_transport->kdbus, flags, 0, &msg); + + if (0 != ret) + { + _dbus_verbose ("kdbus error receiving message: %d (%s)\n", ret, _dbus_strerror (ret)); + _dbus_string_set_length (buffer, start); + return -1; + } + + 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; + + ret = _kdbus_free_mem (kdbus_transport->kdbus, msg); + if (0 != ret) + { + _dbus_verbose ("kdbus error freeing message: %d (%s)\n", ret, _dbus_strerror (ret)); + 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) +{ + DBusTransportKdbus *kdbus_transport = (DBusTransportKdbus *)transport; + _dbus_verbose ("\n"); + + free_watches (transport); + + _dbus_transport_finalize_base (transport); + + _dbus_assert (kdbus_transport->read_watch == NULL); + _dbus_assert (kdbus_transport->write_watch == NULL); + + free_matchmaker (kdbus_transport->matchmaker); + + dbus_free (kdbus_transport->activator); + + _kdbus_free (kdbus_transport->kdbus); + + 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_fd (kdbus_transport->kdbus), + _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_fd (kdbus_transport->kdbus)); + + 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_fd (kdbus_transport->kdbus)); + + 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 + { +#if defined (DBUS_ENABLE_VERBOSE_MODE) || !defined (DBUS_DISABLE_ASSERT) + 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); + + _dbus_assert (bytes_written == total_bytes_to_write); +#endif + total += bytes_written; + + _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_fd (kdbus_transport->kdbus)); + + 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); + + _kdbus_close (kdbus_transport->kdbus); +} + +/** + * 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; + + _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_fd (kdbus_transport->kdbus)); + + poll_fd.fd = _kdbus_fd (kdbus_transport->kdbus); + 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_fd (kdbus_transport->kdbus); + + 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 +}; + +typedef unsigned long (*ConnectionInfoExtractField) (struct nameInfo *); + +static inline unsigned long +_extract_name_info_userId (struct nameInfo *nameInfo) +{ + return nameInfo->userId; +} + +static inline unsigned long +_extract_name_info_processId (struct nameInfo *nameInfo) +{ + return nameInfo->processId; +} + +static dbus_bool_t +_dbus_transport_kdbus_get_connection_info_ulong_field (DBusTransport *transport, + ConnectionInfoExtractField function, + unsigned long *val) +{ + struct nameInfo conn_info; + int ret; + + ret = _kdbus_connection_info_by_id (get_kdbus (transport), + _kdbus_id (get_kdbus (transport)), + FALSE, + &conn_info); + if (ret != 0) + return FALSE; + + *val = function (&conn_info); + return TRUE; +} + +static dbus_bool_t +_dbus_transport_kdbus_get_unix_user (DBusTransport *transport, + unsigned long *uid) +{ + return _dbus_transport_kdbus_get_connection_info_ulong_field (transport, + _extract_name_info_userId, + uid); +} + +static dbus_bool_t +_dbus_transport_kdbus_get_unix_process_id (DBusTransport *transport, + unsigned long *pid) +{ + return _dbus_transport_kdbus_get_connection_info_ulong_field (transport, + _extract_name_info_processId, + pid); +} + +/** + * 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 (kdbus_t *kdbus, + const DBusString *address, + const char *activator) +{ + DBusTransportKdbus *kdbus_transport; + + kdbus_transport = dbus_new0 (DBusTransportKdbus, 1); + if (kdbus_transport == NULL) + return NULL; + + kdbus_transport->kdbus = kdbus; + + kdbus_transport->write_watch = _dbus_watch_new (_kdbus_fd (kdbus), + DBUS_WATCH_WRITABLE, + FALSE, + NULL, NULL, NULL); + if (kdbus_transport->write_watch == NULL) + goto failed_2; + + kdbus_transport->read_watch = _dbus_watch_new (_kdbus_fd (kdbus), + DBUS_WATCH_READABLE, + FALSE, + NULL, NULL, NULL); + if (kdbus_transport->read_watch == NULL) + goto failed_3; + + if (!_dbus_transport_init_base_authenticated (&kdbus_transport->base, + &kdbus_vtable, + NULL, address)) + goto failed_4; + + _dbus_transport_set_get_unix_user_function (&kdbus_transport->base, + _dbus_transport_kdbus_get_unix_user); + _dbus_transport_set_get_unix_process_id_function (&kdbus_transport->base, + _dbus_transport_kdbus_get_unix_process_id); + _dbus_transport_set_assure_protocol_function (&kdbus_transport->base, + _dbus_message_assure_gvariant); + + /* 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; + + 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_4; + } + } + else + kdbus_transport->activator = NULL; + + kdbus_transport->matchmaker = matchmaker_new (); + + kdbus_transport->client_serial = 1; + + 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; +} + +/** + * 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 ret; + DBusTransport *transport; + DBusString address; + kdbus_t *kdbus; + + 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; + } + + 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; + } + + kdbus = _kdbus_new (); + if (NULL == kdbus) + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL); + goto failed_0; + } + + ret = _kdbus_open (kdbus, path); + if (ret < 0) + { + dbus_set_error (error, + _dbus_error_from_errno (-ret), + "Failed to open file descriptor: %s: %s", + path, + _dbus_strerror (-ret)); + goto failed_0_with_kdbus; + } + + _dbus_verbose ("Successfully connected to kdbus bus %s\n", path); + + transport = new_kdbus_transport (kdbus, &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: + _kdbus_close (kdbus); +failed_0_with_kdbus: + _kdbus_free (kdbus); +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; + } +} + +/** @} */ diff --git a/dbus/dbus-transport-kdbus.h b/dbus/dbus-transport-kdbus.h new file mode 100644 index 0000000..75818f1 --- /dev/null +++ b/dbus/dbus-transport-kdbus.h @@ -0,0 +1,34 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ +/* dbus-transport-kdbus.h kdbus subclasses of DBusTransport + * + * Copyright (C) 2013-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_TRANSPORT_KDBUS_H_ +#define DBUS_TRANSPORT_KDBUS_H_ + +#include "dbus-transport-protected.h" + +#define REGISTER_FLAG_MONITOR 1 << 0 + +DBusTransportOpenResult _dbus_transport_open_kdbus (DBusAddressEntry *entry, + DBusTransport **transport_p, + DBusError *error); + +#endif diff --git a/dbus/dbus-transport-protected.h b/dbus/dbus-transport-protected.h index ee627a3..71c3857 100644 --- a/dbus/dbus-transport-protected.h +++ b/dbus/dbus-transport-protected.h @@ -71,6 +71,11 @@ struct DBusTransportVTable /**< Get socket file descriptor */ }; +typedef dbus_bool_t (*DBusTransportGetUnixUserFunction) (DBusTransport *transport, + unsigned long *uid); +typedef dbus_bool_t (*DBusTransportGetUnixPIDFunction) (DBusTransport *transport, + unsigned long *uid); +typedef dbus_bool_t (*DBusTransportAssureProtocolFunction) (DBusMessage **message); /** * Object representing a transport such as a socket. * A transport can shuttle messages from point A to point B, @@ -109,6 +114,10 @@ struct DBusTransport void *windows_user_data; /**< Data for windows_user_function */ DBusFreeFunction free_windows_user_data; /**< Function to free windows_user_data */ + + DBusTransportGetUnixUserFunction get_unix_user_function; /**< Function for getting Unix user ID */ + DBusTransportGetUnixPIDFunction get_unix_process_id_function; /**< Function for getting Unix process ID */ + DBusTransportAssureProtocolFunction assure_protocol_function; /**< Function for converting messages, if needed */ unsigned int disconnected : 1; /**< #TRUE if we are disconnected. */ unsigned int authenticated : 1; /**< Cache of auth state; use _dbus_transport_peek_is_authenticated() to query value */ @@ -123,8 +132,18 @@ dbus_bool_t _dbus_transport_init_base (DBusTransport *transport, const DBusTransportVTable *vtable, const DBusString *server_guid, const DBusString *address); +dbus_bool_t _dbus_transport_init_base_authenticated (DBusTransport *transport, + const DBusTransportVTable *vtable, + const DBusString *server_guid, + const DBusString *address); void _dbus_transport_finalize_base (DBusTransport *transport); +void _dbus_transport_set_get_unix_user_function (DBusTransport *transport, + DBusTransportGetUnixUserFunction function); +void _dbus_transport_set_get_unix_process_id_function (DBusTransport *transport, + DBusTransportGetUnixPIDFunction function); +void _dbus_transport_set_assure_protocol_function (DBusTransport *transport, + DBusTransportAssureProtocolFunction function); typedef enum { diff --git a/dbus/dbus-transport.c b/dbus/dbus-transport.c index 31586b1..e94b9e4 100644 --- a/dbus/dbus-transport.c +++ b/dbus/dbus-transport.c @@ -2,6 +2,7 @@ /* 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 * @@ -32,6 +33,9 @@ #include "dbus-credentials.h" #include "dbus-mainloop.h" #include "dbus-message.h" +#ifdef ENABLE_KDBUS_TRANSPORT +#include "dbus-transport-kdbus.h" +#endif #ifdef DBUS_ENABLE_EMBEDDED_TESTS #include "dbus-server-debug-pipe.h" #endif @@ -85,6 +89,58 @@ live_messages_notify (DBusCounter *counter, _dbus_connection_unlock (transport->connection); } +static dbus_bool_t +_dbus_transport_default_get_unix_user (DBusTransport *transport, + unsigned long *uid) +{ + DBusCredentials *auth_identity; + + *uid = _DBUS_INT32_MAX; /* better than some root or system user in + * case of bugs in the caller. Caller should + * never use this value on purpose, however. + */ + + if (!transport->authenticated) + return FALSE; + + auth_identity = _dbus_auth_get_identity (transport->auth); + + if (_dbus_credentials_include (auth_identity, + DBUS_CREDENTIAL_UNIX_USER_ID)) + { + *uid = _dbus_credentials_get_unix_uid (auth_identity); + return TRUE; + } + else + return FALSE; +} + +static dbus_bool_t +_dbus_transport_default_get_unix_process_id (DBusTransport *transport, + unsigned long *pid) +{ + DBusCredentials *auth_identity; + + *pid = DBUS_PID_UNSET; /* Caller should never use this value on purpose, + * but we set it to a safe number, INT_MAX, + * just to root out possible bugs in bad callers. + */ + + if (!transport->authenticated) + return FALSE; + + auth_identity = _dbus_auth_get_identity (transport->auth); + + if (_dbus_credentials_include (auth_identity, + DBUS_CREDENTIAL_UNIX_PROCESS_ID)) + { + *pid = _dbus_credentials_get_pid (auth_identity); + return TRUE; + } + else + return FALSE; +} + /** * Initializes the base class members of DBusTransport. Chained up to * by subclasses in their constructor. The server GUID is the @@ -96,13 +152,15 @@ live_messages_notify (DBusCounter *counter, * @param vtable the subclass vtable. * @param server_guid non-#NULL if this transport is on the server side of a connection * @param address the address of the transport + * @param with_auth TRUE if authentication should be used * @returns #TRUE on success. */ -dbus_bool_t -_dbus_transport_init_base (DBusTransport *transport, - const DBusTransportVTable *vtable, - const DBusString *server_guid, - const DBusString *address) +static dbus_bool_t +_dbus_transport_init_base_with_auth (DBusTransport *transport, + const DBusTransportVTable *vtable, + const DBusString *server_guid, + const DBusString *address, + dbus_bool_t with_auth) { DBusMessageLoader *loader; DBusAuth *auth; @@ -117,7 +175,13 @@ _dbus_transport_init_base (DBusTransport *transport, if (server_guid) auth = _dbus_auth_server_new (server_guid); else - auth = _dbus_auth_client_new (); + { + if (with_auth) + auth = _dbus_auth_client_new (); + else + auth = _dbus_auth_client_new_authenticated (); + } + if (auth == NULL) { _dbus_message_loader_unref (loader); @@ -203,9 +267,68 @@ _dbus_transport_init_base (DBusTransport *transport, if (transport->address) _dbus_verbose ("Initialized transport on address %s\n", transport->address); + transport->get_unix_user_function = _dbus_transport_default_get_unix_user; + transport->get_unix_process_id_function = _dbus_transport_default_get_unix_process_id; + transport->assure_protocol_function = _dbus_message_assure_dbus1; + return TRUE; } +dbus_bool_t +_dbus_transport_assure_protocol_version (DBusTransport *transport, + DBusMessage **message) +{ + return transport->assure_protocol_function (message); +} + +/** + * Initializes the base class members of DBusTransport. Chained up to + * by subclasses in their constructor. The server GUID is the + * globally unique ID for the server creating this connection + * and will be #NULL for the client side of a connection. The GUID + * is in hex format. + * + * @param transport the transport being created. + * @param vtable the subclass vtable. + * @param server_guid non-#NULL if this transport is on the server side of a connection + * @param address the address of the transport + * @returns #TRUE on success. + */ +dbus_bool_t +_dbus_transport_init_base (DBusTransport *transport, + const DBusTransportVTable *vtable, + const DBusString *server_guid, + const DBusString *address) +{ + return _dbus_transport_init_base_with_auth (transport, vtable, server_guid, address, TRUE); +} + +/** + * Initializes the base class members of DBusTransport. Chained up to + * by subclasses in their constructor. The server GUID is the + * globally unique ID for the server creating this connection + * and will be #NULL for the client side of a connection. The GUID + * is in hex format. Differs from _dbus_transport_init_base in that + * it sets auth as authenticated. This way auth negotiation is skipped. + * + * @param transport the transport being created. + * @param vtable the subclass vtable. + * @param server_guid non-#NULL if this transport is on the server side of a connection + * @param address the address of the transport + * @returns #TRUE on success. + */ +dbus_bool_t +_dbus_transport_init_base_authenticated (DBusTransport *transport, + const DBusTransportVTable *vtable, + const DBusString *server_guid, + const DBusString *address) +{ + dbus_bool_t result = _dbus_transport_init_base_with_auth (transport, vtable, server_guid, address, FALSE); + if (result) + transport->authenticated = TRUE; + return result; +} + /** * Finalizes base class members of DBusTransport. * Chained up to from subclass finalizers. @@ -347,6 +470,9 @@ static const struct { 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 } @@ -1300,6 +1426,47 @@ _dbus_transport_get_max_received_unix_fds (DBusTransport *transport) } /** + * Sets a function used to get UNIX user ID of the connection. + * See dbus_connection_get_unix_user(). + * + * @param transport the transport + * @param function the getter function + */ +void +_dbus_transport_set_get_unix_user_function (DBusTransport *transport, + DBusTransportGetUnixUserFunction function) +{ + transport->get_unix_user_function = function; +} + +/** + * Sets a function used to get process ID of the connection. + * See dbus_connection_get_unix_process_id(). + * + * @param transport the transport + * @param function the getter function + */ +void +_dbus_transport_set_get_unix_process_id_function (DBusTransport *transport, + DBusTransportGetUnixPIDFunction function) +{ + transport->get_unix_process_id_function = function; +} + +/** + * Sets a function used to assure that messages have correct protocol version + * + * @param transport the transport + * @param function the getter function + */ +void +_dbus_transport_set_assure_protocol_function (DBusTransport *transport, + DBusTransportAssureProtocolFunction function) +{ + transport->assure_protocol_function = function; +} + +/** * See dbus_connection_get_unix_user(). * * @param transport the transport @@ -1310,26 +1477,9 @@ dbus_bool_t _dbus_transport_get_unix_user (DBusTransport *transport, unsigned long *uid) { - DBusCredentials *auth_identity; - - *uid = _DBUS_INT32_MAX; /* better than some root or system user in - * case of bugs in the caller. Caller should - * never use this value on purpose, however. - */ - - if (!transport->authenticated) - return FALSE; - - auth_identity = _dbus_auth_get_identity (transport->auth); - - if (_dbus_credentials_include (auth_identity, - DBUS_CREDENTIAL_UNIX_USER_ID)) - { - *uid = _dbus_credentials_get_unix_uid (auth_identity); - return TRUE; - } - else + if (transport->get_unix_user_function == NULL) return FALSE; + return (transport->get_unix_user_function) (transport, uid); } /** @@ -1343,26 +1493,9 @@ dbus_bool_t _dbus_transport_get_unix_process_id (DBusTransport *transport, unsigned long *pid) { - DBusCredentials *auth_identity; - - *pid = DBUS_PID_UNSET; /* Caller should never use this value on purpose, - * but we set it to a safe number, INT_MAX, - * just to root out possible bugs in bad callers. - */ - - if (!transport->authenticated) - return FALSE; - - auth_identity = _dbus_auth_get_identity (transport->auth); - - if (_dbus_credentials_include (auth_identity, - DBUS_CREDENTIAL_UNIX_PROCESS_ID)) - { - *pid = _dbus_credentials_get_pid (auth_identity); - return TRUE; - } - else + if (transport->get_unix_process_id_function == NULL) return FALSE; + return (transport->get_unix_process_id_function) (transport, pid); } /** diff --git a/dbus/dbus-transport.h b/dbus/dbus-transport.h index 9e3787d..69cc4f2 100644 --- a/dbus/dbus-transport.h +++ b/dbus/dbus-transport.h @@ -105,6 +105,10 @@ void _dbus_transport_set_pending_fds_function (DBusTransport *tran void (* callback) (void *), void *data); +dbus_bool_t _dbus_transport_assure_protocol_version (DBusTransport *transport, + DBusMessage **message); + + /* if DBUS_ENABLE_STATS */ void _dbus_transport_get_stats (DBusTransport *transport, dbus_uint32_t *queue_bytes, diff --git a/dbus/kdbus-common.c b/dbus/kdbus-common.c new file mode 100644 index 0000000..facd45a --- /dev/null +++ b/dbus/kdbus-common.c @@ -0,0 +1,1026 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include "dbus-signals.h" +#include +#include +#include +#include +#include +#include + +struct kdbus_t +{ + int fd; /**< File descriptor */ + void *mmap_ptr; /**< Mapped memory where kdbus (kernel) writes + * messages incoming to us. + */ + size_t pool_size; /**< Size of mapped memory */ + __u64 id; /**< unique id of the connection */ + char bus_id[sizeof(((struct kdbus_cmd_hello *)(0))->id128)]; /**< id of the bus */ + struct kdbus_bloom_parameter bloom; /**< bloom parameters*/ +}; + +/** temporary accessors - to delete soon */ +int _kdbus_fd (kdbus_t *kdbus) { return kdbus->fd; } +void *_kdbus_mmap_ptr (kdbus_t *kdbus) { return kdbus->mmap_ptr; } +dbus_uint64_t _kdbus_id (kdbus_t *kdbus) { return kdbus->id; } +char *_kdbus_bus_id (kdbus_t *kdbus) { return kdbus->bus_id; } +dbus_uint64_t _kdbus_bus_id_size (void) { return sizeof(((struct kdbus_t *)(0))->bus_id); } +struct kdbus_bloom_parameter *_kdbus_bloom (kdbus_t *kdbus) { return &kdbus->bloom; } + + + +/* 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))) + +static int +safe_ioctl (int fd, + unsigned long request, + void *data) +{ + int ret; + + do { + ret = ioctl (fd, request, data); + } + while (-1 == ret && EINTR == errno); + + return ret; +} + +static int +free_by_offset (kdbus_t *kdbus, + __u64 offset) +{ + struct kdbus_cmd_free cmd; + + cmd.size = sizeof (cmd); + cmd.offset = offset; + cmd.flags = 0; + + if (safe_ioctl (kdbus->fd, KDBUS_CMD_FREE, &cmd )!= 0) + return errno; + + return 0; +} + +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); +} + +/** + * Adds an item in the current position of items array. + * + * @param item item to fill + * @param item_type type of the item + * @param string value of the item + * @param string_size size of the value + * @returns pointer to the next item + */ +struct kdbus_item * +_kdbus_item_add_string (struct kdbus_item *item, + dbus_uint64_t item_type, + const char *item_string, + dbus_uint64_t item_string_size) +{ + item->size = KDBUS_ITEM_HEADER_SIZE + item_string_size; + item->type = item_type; + memcpy (item->str, item_string, item_string_size); + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_payload_memfd (struct kdbus_item *item, + dbus_uint64_t start, + dbus_uint64_t size, + int fd) +{ + item->type = KDBUS_ITEM_PAYLOAD_MEMFD; + item->size = KDBUS_ITEM_HEADER_SIZE + sizeof (struct kdbus_memfd); + item->memfd.start = start; + item->memfd.size = size; + item->memfd.fd = fd; + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_payload_vec (struct kdbus_item *item, + dbus_uint64_t size, + dbus_uint64_t address_or_offset) +{ + item->type = KDBUS_ITEM_PAYLOAD_VEC; + item->size = KDBUS_ITEM_HEADER_SIZE + sizeof (struct kdbus_vec); + item->vec.size = size; + item->vec.address = address_or_offset; + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_fds (struct kdbus_item *item, + const int *fds, + int fds_count) +{ + item->type = KDBUS_ITEM_FDS; + item->size = KDBUS_ITEM_HEADER_SIZE + fds_count * sizeof (int); + memcpy (item->fds, fds, fds_count * sizeof (int)); + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_bloom_filter (struct kdbus_item *item, + dbus_uint64_t data_size, + struct kdbus_bloom_filter **out_ptr) +{ + item->type = KDBUS_ITEM_BLOOM_FILTER; + item->size = KDBUS_ITEM_HEADER_SIZE + sizeof (struct kdbus_bloom_filter) + data_size; + *out_ptr = &item->bloom_filter; + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_name_change (struct kdbus_item *item, + dbus_uint64_t old_id, + dbus_uint64_t old_id_flags, + dbus_uint64_t new_id, + dbus_uint64_t new_id_flags) +{ + item->size = KDBUS_ITEM_HEADER_SIZE + sizeof (struct kdbus_notify_name_change); + item->type = KDBUS_ITEM_NAME_CHANGE; + item->name_change.old_id.id = old_id; + item->name_change.old_id.flags = old_id_flags; + item->name_change.new_id.id = new_id; + item->name_change.new_id.flags = new_id_flags; + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_id_add (struct kdbus_item *item, + dbus_uint64_t id, + dbus_uint64_t id_flags) +{ + item->size = KDBUS_ITEM_HEADER_SIZE + sizeof (struct kdbus_notify_id_change); + item->type = KDBUS_ITEM_ID_ADD; + item->id_change.id = id; + item->id_change.flags = id_flags; + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_id (struct kdbus_item *item, + dbus_uint64_t id) +{ + item->size = KDBUS_ITEM_HEADER_SIZE + sizeof (struct kdbus_notify_id_change); + item->type = KDBUS_ITEM_ID; + item->id = id; + return KDBUS_ITEM_NEXT (item); +} + +struct kdbus_item * +_kdbus_item_add_bloom_mask (struct kdbus_item *item, + dbus_uint64_t *bloom, + dbus_uint64_t bloom_size) +{ + item->size = KDBUS_ITEM_HEADER_SIZE + bloom_size; + item->type = KDBUS_ITEM_BLOOM_MASK; + memcpy (item->data, bloom, bloom_size); + return KDBUS_ITEM_NEXT (item); +} + +static inline void * +get_from_offset (kdbus_t *kdbus, + __u64 offset) +{ + return ((char *)kdbus->mmap_ptr) + offset; +} + +kdbus_t * +_kdbus_new () +{ + return dbus_new (kdbus_t, 1); +} + +void +_kdbus_free (kdbus_t *kdbus) +{ + dbus_free (kdbus); +} + +/** + * Opens a connection to the kdbus bus + * + * @param kdbus kdbus object + * @param path the path to kdbus bus + * @returns 0 on success, -errno on failure + */ +int +_kdbus_open (kdbus_t *kdbus, const char *path) +{ + int fd = open (path, O_RDWR|O_CLOEXEC|O_NONBLOCK); + if (-1 == fd) + return -errno; + + kdbus->fd = fd; + return 0; +} + +int +_kdbus_close (kdbus_t *kdbus) +{ + int ret; + int errclose = 0; + int errunmap = 0; + + do + { + ret = close (kdbus->fd); + } while (-1 == ret && EINTR == errno); + if (-1 == ret) + errclose = errno; + + ret = munmap (kdbus->mmap_ptr, kdbus->pool_size); + if (-1 == ret) + errunmap = errno; + + if (0 != errclose) + return -errclose; + if (0 != errunmap) + return -errunmap; + return 0; +} + +int +_kdbus_hello (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_uint64_t attach_flags_send, + dbus_uint64_t attach_flags_recv, + dbus_uint64_t pool_size, + const char *activator_name, + const char *connection_name) +{ + struct kdbus_cmd_hello *hello; + struct kdbus_item *item, *items; + __u64 hello_size; + size_t activator_name_size = 0; + size_t connection_name_size = 0; + __u64 offset; + __u64 items_size; + + hello_size = sizeof (struct kdbus_cmd_hello); + + if (NULL != activator_name) + { + activator_name_size = strlen (activator_name) + 1; + hello_size += KDBUS_ITEM_SIZE (activator_name_size); + } + + if (NULL != connection_name) + { + connection_name_size = strlen (connection_name) + 1; + hello_size += KDBUS_ITEM_SIZE (connection_name_size); + } + + hello = dbus_malloc (hello_size); + if (NULL == hello) + return -ENOMEM; + + hello->flags = flags; + hello->attach_flags_send = attach_flags_send; + hello->attach_flags_recv = attach_flags_recv; + hello->pool_size = pool_size; + + item = hello->items; + if (connection_name_size > 0) + item = _kdbus_item_add_string (item, + KDBUS_ITEM_CONN_DESCRIPTION, + connection_name, + connection_name_size); + if (activator_name_size > 0) + { + _kdbus_item_add_string (item, + KDBUS_ITEM_NAME, + activator_name, + activator_name_size); + hello->flags |= KDBUS_HELLO_ACTIVATOR; + } + + hello->size = hello_size; + + if (safe_ioctl (kdbus->fd, KDBUS_CMD_HELLO, hello) != 0) + { + dbus_free (hello); + return -errno; + } + + kdbus->id = hello->id; + memcpy (kdbus->bus_id, hello->id128, sizeof (kdbus->bus_id)); + + offset = hello->offset; + items_size = hello->items_size; + dbus_free (hello); + + kdbus->mmap_ptr = mmap (NULL, pool_size, PROT_READ, MAP_SHARED, kdbus->fd, 0); + if (MAP_FAILED == kdbus->mmap_ptr) + return -errno; + + kdbus->pool_size = pool_size; + + items = get_from_offset (kdbus, offset); + KDBUS_FOREACH (item, items, items_size) + { + if (KDBUS_ITEM_BLOOM_PARAMETER == item->type) + kdbus->bloom = item->bloom_parameter; + } + + return 0; +} + +int +_kdbus_send (kdbus_t *kdbus, + dbus_uint64_t flags, + struct kdbus_msg *msg, + struct kdbus_msg **msg_reply) +{ + struct kdbus_cmd_send cmd; + + cmd.size = sizeof(cmd); + cmd.msg_address = (__u64)msg; + cmd.flags = flags; + + if (-1 == safe_ioctl (kdbus->fd, KDBUS_CMD_SEND, &cmd)) + return errno; + + if (flags & KDBUS_SEND_SYNC_REPLY) + { + if (NULL != msg_reply) + *msg_reply = get_from_offset (kdbus, cmd.reply.offset); + else + free_by_offset (kdbus, cmd.reply.offset); + } + + return 0; +} + +int +_kdbus_recv (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_int64_t priority, + struct kdbus_msg **msg) +{ + struct kdbus_cmd_recv cmd; + + cmd.size = sizeof (cmd); + cmd.flags = flags; + cmd.priority = priority; + + if (-1 == safe_ioctl (kdbus->fd, KDBUS_CMD_RECV, &cmd)) + return errno; + + *msg = get_from_offset (kdbus, cmd.msg.offset); + + return 0; +} + +int +_kdbus_list (kdbus_t *kdbus, + dbus_uint64_t flags, + struct kdbus_info **name_list, + dbus_uint64_t *list_size) +{ + struct kdbus_cmd_list cmd; + + cmd.size = sizeof (cmd); + cmd.flags = flags; + + if (-1 == safe_ioctl (kdbus->fd, KDBUS_CMD_LIST, &cmd)) + return errno; + + *name_list = get_from_offset (kdbus, cmd.offset); + *list_size = cmd.list_size; + + return 0; +} + +struct kdbus_cmd_match * +_kdbus_new_cmd_match (kdbus_t *kdbus, + dbus_uint64_t items_size, + dbus_uint64_t flags, + dbus_uint64_t cookie) +{ + struct kdbus_cmd_match *cmd; + dbus_uint64_t cmd_size = sizeof (*cmd) + items_size; + cmd = dbus_malloc (cmd_size); + if (NULL == cmd) + return NULL; + + cmd->size = cmd_size; + cmd->flags = flags; + cmd->cookie = cookie; + + return cmd; +} + +void +_kdbus_free_cmd_match (struct kdbus_cmd_match *cmd) +{ + dbus_free (cmd); +} + +int +_kdbus_add_match_name_change (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_uint64_t cookie, + dbus_uint64_t old_id, + dbus_uint64_t old_id_flags, + dbus_uint64_t new_id, + dbus_uint64_t new_id_flags) +{ + struct kdbus_cmd_match *cmd; + struct kdbus_item *item; + int ret; + + cmd = _kdbus_new_cmd_match (kdbus, + KDBUS_ITEM_SIZE (sizeof (struct kdbus_notify_name_change)), + flags, + cookie); + if (NULL == cmd) + return ENOMEM; + + item = cmd->items; + _kdbus_item_add_name_change (item, + old_id, old_id_flags, + new_id, new_id_flags); + + ret = safe_ioctl (kdbus->fd, KDBUS_CMD_MATCH_ADD, cmd); + if (0 == ret) + { + item->type = KDBUS_ITEM_NAME_ADD; + ret = safe_ioctl (kdbus->fd, KDBUS_CMD_MATCH_ADD, cmd); + if (0 == ret) + { + item->type = KDBUS_ITEM_NAME_REMOVE; + ret = safe_ioctl (kdbus->fd, KDBUS_CMD_MATCH_ADD, cmd); + } + } + + if (0 != ret) + ret = errno; + + _kdbus_free_cmd_match (cmd); + return ret; +} + +int +_kdbus_add_match_id_change (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_uint64_t cookie, + dbus_uint64_t id, + dbus_uint64_t id_flags) +{ + struct kdbus_cmd_match *cmd; + struct kdbus_item *item; + int ret; + + cmd = _kdbus_new_cmd_match (kdbus, + KDBUS_ITEM_SIZE (sizeof (struct kdbus_notify_id_change)), + flags, + cookie); + if (NULL == cmd) + return ENOMEM; + + item = cmd->items; + _kdbus_item_add_id_add (item, id, id_flags); + + ret = safe_ioctl (kdbus->fd, KDBUS_CMD_MATCH_ADD, cmd); + if (0 == ret) + { + item->type = KDBUS_ITEM_ID_REMOVE; + ret = safe_ioctl (kdbus->fd, KDBUS_CMD_MATCH_ADD, cmd); + } + + if (0 != ret) + ret = errno; + + _kdbus_free_cmd_match (cmd); + return ret; +} + +int _kdbus_add_match (kdbus_t *kdbus, + struct kdbus_cmd_match *cmd) +{ + int ret = safe_ioctl (kdbus->fd, KDBUS_CMD_MATCH_ADD, cmd); + if (0 != ret) + return errno; + + return 0; +} + +/** + * Allocates and initializes kdbus message structure. + * @param kdbus kdbus object + * @param size_for_items size of items that will be attached to this message + * @param flags flags for message + * @returns initialized kdbus message or NULL if malloc failed + */ +struct kdbus_msg * +_kdbus_new_msg (kdbus_t *kdbus, + dbus_uint64_t size_for_items, + dbus_uint64_t flags, + dbus_int64_t priority, + dbus_uint64_t dst_id, + dbus_uint64_t src_id, + enum kdbus_payload_type payload_type, + dbus_uint64_t cookie, + dbus_uint64_t timeout_ns_or_cookie_reply) +{ + struct kdbus_msg *msg; + dbus_uint64_t msg_size = sizeof (struct kdbus_msg) + size_for_items; + + msg = dbus_malloc (msg_size); + if (NULL == msg) + return NULL; + + msg->size = msg_size; + msg->flags = flags; + msg->priority = priority; + msg->dst_id = dst_id; + msg->src_id = src_id; + msg->payload_type = payload_type; + msg->cookie = cookie; + msg->timeout_ns = timeout_ns_or_cookie_reply; + + return msg; +} + +void +_kdbus_free_msg (struct kdbus_msg *msg) +{ + dbus_free (msg); +} + +int +_kdbus_free_mem (kdbus_t *kdbus, void *mem) +{ + char *base_ptr = kdbus->mmap_ptr; + char *mem_ptr = (char *)mem; + + return free_by_offset (kdbus, mem_ptr - base_ptr); +} + +/** + * Computes size of items that will be attached to a message. + * + * @param kdbus kdbus object + * @param destination 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. + * @returns size in bytes needed for the message object + */ +dbus_uint64_t +_kdbus_compute_msg_items_size (kdbus_t *kdbus, + const char *destination, + dbus_uint64_t dst_id, + dbus_uint64_t body_size, + dbus_bool_t use_memfd, + int fds_count) +{ + dbus_uint64_t items_size = 0; + + if (use_memfd) + { + items_size += KDBUS_ITEM_SIZE (sizeof (struct kdbus_memfd)); + } + else + { + dbus_uint64_t vectors = (body_size + KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE - 1) + / KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE; + /* 1st vector -> for header */ + items_size += KDBUS_ITEM_SIZE (sizeof (struct kdbus_vec)); + /* subsequent vectors -> parts of body */ + items_size += vectors * KDBUS_ITEM_SIZE (sizeof (struct kdbus_vec)); + } + + if (fds_count > 0) + items_size += KDBUS_ITEM_SIZE (sizeof (int) * fds_count); + + if (destination) + items_size += KDBUS_ITEM_SIZE (strlen (destination) + 1); + else if (KDBUS_DST_ID_BROADCAST == dst_id) + items_size += KDBUS_ITEM_SIZE (sizeof (struct kdbus_bloom_filter)) + + kdbus->bloom.size; + return items_size; +} + +/** + * + * 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; +} + +static int +decode_connection_info (struct kdbus_info *connection_info, + struct nameInfo *pInfo, + dbus_bool_t get_sec_label) +{ + struct kdbus_item *item; + + memset (pInfo, 0, sizeof(*pInfo)); + + pInfo->uniqueId = connection_info->id; + pInfo->flags = connection_info->flags; + + item = connection_info->items; + + while ((uint8_t *)item < ((uint8_t *)connection_info) + connection_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: + if (get_sec_label) + { + pInfo->sec_label_len = item->size - KDBUS_ITEM_HEADER_SIZE - 1; + if (0 != pInfo->sec_label_len) + { + pInfo->sec_label = dbus_malloc (pInfo->sec_label_len); + if (NULL == pInfo->sec_label) + return ENOMEM; + + memcpy (pInfo->sec_label, item->data, pInfo->sec_label_len); + } + } + break; + } + + item = KDBUS_ITEM_NEXT (item); + } + return 0; +} + +static int +process_connection_info_cmd (kdbus_t *kdbus, + struct kdbus_cmd_info *cmd, + struct nameInfo *pInfo, + dbus_bool_t get_sec_label) +{ + int ret; + struct kdbus_info *kdbus_info; + + if (NULL == cmd) + return -1; + + ret = safe_ioctl (kdbus->fd, KDBUS_CMD_CONN_INFO, cmd); + + if (ret < 0) + { + pInfo->uniqueId = 0; + return errno; + } + + kdbus_info = get_from_offset (kdbus, cmd->offset); + ret = decode_connection_info (kdbus_info, + pInfo, + get_sec_label); + if (ret != 0) + return ret; + + ret = free_by_offset (kdbus, cmd->offset); + if (ret != 0) + { + _dbus_verbose("kdbus error freeing pool: %d (%m)\n", errno); + if (get_sec_label) + { + free(pInfo->sec_label); + pInfo->sec_label = NULL; + } + } + + dbus_free (cmd); + + return ret; +} + +static struct kdbus_cmd_info * +prepare_connection_info_cmd (dbus_uint64_t id, + const char *name, + dbus_bool_t get_sec_label) +{ + struct kdbus_cmd_info *cmd; + dbus_uint64_t size = sizeof(*cmd); + if (NULL != name) + { + size += KDBUS_ITEM_SIZE (strlen (name) + 1); + } + cmd = dbus_malloc (size); + if (NULL == cmd) + return NULL; + + cmd->size = size; + cmd->id = id; + if (0 == id) + make_item_name (name, &(cmd->items[0])); + + cmd->attach_flags = KDBUS_ATTACH_CREDS | KDBUS_ATTACH_PIDS; + if (get_sec_label) + cmd->attach_flags |= KDBUS_ATTACH_SECLABEL; + + cmd->flags = 0; + + return cmd; +} + +/** + * Gets connection info for the given unique id. + * + * @param transport transport + * @param id unique id to query for + * @param get_sec_label #TRUE if sec_label field in pInfo should be filled + * @param pInfo nameInfo structure address to store info about the name + * @return 0 on success, errno if failed + * + * @note If you specify #TRUE in get_sec_label param, you must free + * pInfo.sec_label with dbus_free() after use. + */ +int +_kdbus_connection_info_by_id (kdbus_t *kdbus, + dbus_uint64_t id, + dbus_bool_t get_sec_label, + struct nameInfo *pInfo) +{ + struct kdbus_cmd_info *cmd = prepare_connection_info_cmd (id, NULL, get_sec_label); + + return process_connection_info_cmd (kdbus, cmd, pInfo, get_sec_label); +} + +/** + * Gets connection info for the given name + * + * @param transport transport + * @param name name to query for + * @param get_sec_label #TRUE if sec_label field in pInfo should be filled + * @param pInfo nameInfo structure address to store info about the name + * @return 0 on success, errno if failed + * + * @note If you specify #TRUE in get_sec_label param, you must free + * pInfo.sec_label with dbus_free() after use. + */ +int +_kdbus_connection_info_by_name (kdbus_t *kdbus, + const char *name, + dbus_bool_t get_sec_label, + struct nameInfo *pInfo) +{ + struct kdbus_cmd_info *cmd; + + /* if name starts with ":1." it is a unique name and should be send as number */ + if((name[0] == ':') && (name[1] == '1') && (name[2] == '.')) + { + return _kdbus_connection_info_by_id (kdbus, + strtoull(&name[3], NULL, 10), + get_sec_label, + pInfo); + } + + cmd = prepare_connection_info_cmd (0, name, get_sec_label); + + return process_connection_info_cmd (kdbus, cmd, pInfo, get_sec_label); +} + +/** + * 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; +} diff --git a/dbus/kdbus-common.h b/dbus/kdbus-common.h new file mode 100644 index 0000000..cea606e --- /dev/null +++ b/dbus/kdbus-common.h @@ -0,0 +1,197 @@ +/* -*- 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 +#include +#include "dbus-signals.h" +#include "kdbus.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 */ + +struct nameInfo +{ + __u64 uniqueId; + __u64 flags; + __u64 userId; + __u64 processId; + __u32 sec_label_len; + char *sec_label; +}; + +typedef struct kdbus_t kdbus_t; + +kdbus_t * _kdbus_new (void); +void _kdbus_free (kdbus_t *kdbus); + +int _kdbus_open (kdbus_t *kdbus, const char *path); +int _kdbus_close (kdbus_t *kdbus); + +int _kdbus_hello (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_uint64_t attach_flags_send, + dbus_uint64_t attach_flags_recv, + dbus_uint64_t pool_size, + const char *activator_name, + const char *connection_name); + +int _kdbus_send (kdbus_t *kdbus, + dbus_uint64_t flags, + struct kdbus_msg *msg, + struct kdbus_msg **msg_reply); + +int _kdbus_recv (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_int64_t priority, + struct kdbus_msg **msg); + +int _kdbus_list (kdbus_t *kdbus, + dbus_uint64_t flags, + struct kdbus_info **name_list, + dbus_uint64_t *list_size); + +int _kdbus_add_match_name_change (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_uint64_t cookie, + dbus_uint64_t old_id, + dbus_uint64_t old_id_flags, + dbus_uint64_t new_id, + dbus_uint64_t new_id_flags); + +int _kdbus_add_match_id_change (kdbus_t *kdbus, + dbus_uint64_t flags, + dbus_uint64_t cookie, + dbus_uint64_t id, + dbus_uint64_t id_flags); + +int _kdbus_add_match (kdbus_t *kdbus, + struct kdbus_cmd_match *cmd); + +int _kdbus_connection_info_by_name (kdbus_t *kdbus, + const char *name, + dbus_bool_t get_sec_label, + struct nameInfo *pInfo); + +int _kdbus_connection_info_by_id (kdbus_t *kdbus, + dbus_uint64_t id, + dbus_bool_t get_sec_label, + struct nameInfo *pInfo); + +dbus_uint64_t _kdbus_compute_msg_items_size (kdbus_t *kdbus, + const char *destination, + dbus_uint64_t dst_id, + dbus_uint64_t body_size, + dbus_bool_t use_memfd, + int fds_count); + +struct kdbus_msg * _kdbus_new_msg (kdbus_t *kdbus, + dbus_uint64_t size_for_items, + dbus_uint64_t flags, + dbus_int64_t priority, + dbus_uint64_t dst_id, + dbus_uint64_t src_id, + enum kdbus_payload_type payload_type, + dbus_uint64_t cookie, + dbus_uint64_t timeout_ns_or_cookie_reply); + +void _kdbus_free_msg (struct kdbus_msg *msg); + +struct kdbus_cmd_match *_kdbus_new_cmd_match (kdbus_t *kdbus, + dbus_uint64_t items_size, + dbus_uint64_t flags, + dbus_uint64_t cookie); + +void _kdbus_free_cmd_match (struct kdbus_cmd_match *cmd); + +int _kdbus_free_mem (kdbus_t *kdbus, void *mem); + +struct kdbus_item * _kdbus_item_add_string (struct kdbus_item *item, + dbus_uint64_t item_type, + const char *item_string, + dbus_uint64_t item_string_size); + +struct kdbus_item * _kdbus_item_add_payload_memfd (struct kdbus_item *item, + dbus_uint64_t start, + dbus_uint64_t size, + int fd); + +struct kdbus_item * _kdbus_item_add_payload_vec (struct kdbus_item *item, + dbus_uint64_t size, + dbus_uint64_t address_or_offset); + +struct kdbus_item * _kdbus_item_add_fds (struct kdbus_item *item, + const int *fds, + int fds_count); + +struct kdbus_item * _kdbus_item_add_bloom_filter (struct kdbus_item *item, + dbus_uint64_t data_size, + struct kdbus_bloom_filter **out_ptr); + +struct kdbus_item * _kdbus_item_add_name_change (struct kdbus_item *item, + dbus_uint64_t old_id, + dbus_uint64_t old_id_flags, + dbus_uint64_t new_id, + dbus_uint64_t new_id_flags); + +struct kdbus_item * _kdbus_item_add_id_add (struct kdbus_item *item, + dbus_uint64_t id, + dbus_uint64_t id_flags); + +struct kdbus_item * _kdbus_item_add_id (struct kdbus_item *item, + dbus_uint64_t id); + +struct kdbus_item * _kdbus_item_add_bloom_mask (struct kdbus_item *item, + dbus_uint64_t *bloom, + dbus_uint64_t bloom_size); + +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); + +/** temporary accessors - to delete soon */ +int _kdbus_fd (kdbus_t *kdbus); +void *_kdbus_mmap_ptr (kdbus_t *kdbus); +dbus_uint64_t _kdbus_id (kdbus_t *kdbus); +char *_kdbus_bus_id (kdbus_t *kdbus); +dbus_uint64_t _kdbus_bus_id_size (void); +struct kdbus_bloom_parameter *_kdbus_bloom (kdbus_t *kdbus); + +#endif /* KDBUS_COMMON_H_ */ diff --git a/dbus/kdbus.h b/dbus/kdbus.h new file mode 100644 index 0000000..4fc44cb --- /dev/null +++ b/dbus/kdbus.h @@ -0,0 +1,984 @@ +/* + * 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 +#include + +#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_ */ diff --git a/packaging/dbus-x11.spec b/packaging/dbus-x11.spec index e77c13e..b63ee7f 100644 --- a/packaging/dbus-x11.spec +++ b/packaging/dbus-x11.spec @@ -1,4 +1,5 @@ %bcond_with x +%bcond_with kdbus Name: dbus-x11 %define _name dbus @@ -75,6 +76,9 @@ export V=1 %if %{with_systemd} --enable-systemd \ %endif +%if %{with kdbus} + --enable-kdbus-transport \ +%endif --with-console-auth-dir=/var/run/dbus/at_console/ \ --with-systemdsystemunitdir=%{_unitdir} \ --enable-smack diff --git a/packaging/dbus.spec b/packaging/dbus.spec index 860d70c..2919332 100644 --- a/packaging/dbus.spec +++ b/packaging/dbus.spec @@ -1,5 +1,7 @@ %define dbus_user_uid 81 +%bcond_with kdbus + Name: dbus Url: http://dbus.freedesktop.org/ Summary: D-Bus Message Bus System @@ -90,6 +92,9 @@ export V=1 %if %{with_systemd} --enable-systemd \ %endif +%if %{with kdbus} + --enable-kdbus-transport \ +%endif --with-console-auth-dir=/var/run/dbus/at_console/ \ --with-systemdsystemunitdir=%{_unitdir} \ --enable-smack \ diff --git a/packaging/libdbus.spec b/packaging/libdbus.spec index 2660481..0494b8c 100644 --- a/packaging/libdbus.spec +++ b/packaging/libdbus.spec @@ -1,3 +1,5 @@ +%bcond_with kdbus + Name: libdbus Url: http://dbus.freedesktop.org/ Summary: Library package for D-Bus @@ -68,6 +70,9 @@ export V=1 --enable-inotify \ --with-console-auth-dir=/var/run/dbus/at_console/ \ --with-systemdsystemunitdir=%{_unitdir} \ +%if %{with kdbus} + --enable-kdbus-transport \ +%endif --enable-smack make %{?_smp_mflags} -C dbus libdbus-1.la