From 197db0df78e0a9f82df4162885854f99ff749505 Mon Sep 17 00:00:00 2001 From: "Hyotaek, Shim" Date: Wed, 16 Dec 2015 15:27:54 +0900 Subject: Revert "Add kdbus transport" This reverts commit 771f5155c9a393a242329988d56661a51fc04e6c. Change-Id: I73b6adc6b76b63e972f7228c88c18dabda81b006 --- bus/main.c | 2 - configure.ac | 25 +- dbus/Makefile.am | 22 +- dbus/dbus-asv-util.c | 54 - dbus/dbus-asv-util.h | 30 +- dbus/dbus-auth.c | 33 - dbus/dbus-auth.h | 1 - dbus/dbus-connection-internal.h | 1 - dbus/dbus-connection.c | 116 +- dbus/dbus-marshal-gvariant.c | 1388 -------------- dbus/dbus-marshal-gvariant.h | 132 -- dbus/dbus-marshal-header.c | 304 +-- dbus/dbus-marshal-header.h | 4 +- dbus/dbus-marshal-recursive.c | 496 ++--- dbus/dbus-marshal-recursive.h | 29 - dbus/dbus-message-internal.h | 12 - dbus/dbus-message-private.h | 3 - dbus/dbus-message.c | 620 ++---- dbus/dbus-message.h | 85 +- dbus/dbus-pending-call.c | 3 - dbus/dbus-protocol-gvariant.h | 56 - dbus/dbus-shared.h | 2 - dbus/dbus-signals.c | 1633 ---------------- dbus/dbus-signals.h | 117 -- dbus/dbus-transport-kdbus.c | 4000 --------------------------------------- dbus/dbus-transport-kdbus.h | 34 - dbus/dbus-transport-protected.h | 19 - dbus/dbus-transport.c | 221 +-- dbus/dbus-transport.h | 4 - dbus/kdbus-common.c | 1026 ---------- dbus/kdbus-common.h | 197 -- dbus/kdbus.h | 984 ---------- packaging/dbus-x11.spec | 4 - packaging/dbus.spec | 5 - packaging/libdbus.spec | 5 - 35 files changed, 461 insertions(+), 11206 deletions(-) delete mode 100644 dbus/dbus-marshal-gvariant.c delete mode 100644 dbus/dbus-marshal-gvariant.h delete mode 100644 dbus/dbus-protocol-gvariant.h delete mode 100644 dbus/dbus-signals.c delete mode 100644 dbus/dbus-signals.h delete mode 100644 dbus/dbus-transport-kdbus.c delete mode 100644 dbus/dbus-transport-kdbus.h delete mode 100644 dbus/kdbus-common.c delete mode 100644 dbus/kdbus-common.h delete mode 100644 dbus/kdbus.h diff --git a/bus/main.c b/bus/main.c index 702b5194..e060baa8 100644 --- a/bus/main.c +++ b/bus/main.c @@ -643,8 +643,6 @@ 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 e381860e..ca2c47cf 100644 --- a/configure.ac +++ b/configure.ac @@ -158,7 +158,6 @@ 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])) @@ -1239,12 +1238,6 @@ 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]) - # Determine maximum number of Unix fds which may be passed AS_CASE([$host_os], [*qnx*], @@ -1257,7 +1250,7 @@ AC_DEFINE_UNQUOTED([DBUS_DEFAULT_MESSAGE_UNIX_FDS], AC_SUBST([DEFAULT_MESSAGE_UNIX_FDS]) #### Set up final flags -LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs $KDBUS_LIBS" +LIBDBUS_LIBS="$THREAD_LIBS $NETWORK_libs" AC_SUBST([LIBDBUS_LIBS]) ### X11 detection @@ -1533,20 +1526,7 @@ 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. -#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 +DBUS_SYSTEM_BUS_DEFAULT_ADDRESS="unix:path=$DBUS_SYSTEM_SOCKET" 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]) @@ -1885,7 +1865,6 @@ echo " Building Doxygen docs: ${enable_doxygen_docs} Building XML docs: ${enable_xml_docs} Building launchd support: ${have_launchd} - Building kdbus support: ${enable_kdbus_transport} Init scripts style: ${with_init_scripts} Abstract socket names: ${ac_cv_have_abstract_sockets} System bus socket: ${DBUS_SYSTEM_SOCKET} diff --git a/dbus/Makefile.am b/dbus/Makefile.am index fa712428..86d5d466 100644 --- a/dbus/Makefile.am +++ b/dbus/Makefile.am @@ -112,21 +112,6 @@ DBUS_SHARED_arch_sources = \ sd-daemon.c \ sd-daemon.h -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 \ @@ -245,10 +230,7 @@ DBUS_SHARED_SOURCES= \ $(DBUS_SHARED_arch_sources) \ dbus-sysdeps.c \ dbus-sysdeps.h \ - dbus-valgrind-internal.h \ - dbus-asv-util.c \ - dbus-asv-util.h \ - dbus-string-util.c + dbus-valgrind-internal.h ### source code that is generic utility functionality used ### by the bus daemon or test apps, but is NOT included @@ -256,6 +238,8 @@ 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.c b/dbus/dbus-asv-util.c index e4440f4c..583e41fa 100644 --- a/dbus/dbus-asv-util.c +++ b/dbus/dbus-asv-util.c @@ -258,57 +258,3 @@ _dbus_asv_add_string (DBusMessageIter *arr_iter, return TRUE; } - -/** - * Create a new entry in an a{sv} (map from string to variant) - * with an array of bytes value. - * - * If this function fails, the a{sv} must be abandoned, for instance - * with _dbus_asv_abandon(). - * - * @param arr_iter the iterator which is appending to the array - * @param key a UTF-8 key for the map - * @param value the value - * @returns #TRUE on success, or #FALSE if not enough memory - */ -dbus_bool_t -_dbus_asv_add_array_of_bytes (DBusMessageIter *arr_iter, - const char *key, - const void *value, - unsigned int value_len) -{ - DBusMessageIter entry_iter, var_iter, sub_array_iter; - - if (!_dbus_asv_open_entry (arr_iter, &entry_iter, key, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING, - &var_iter)) - return FALSE; - - if (!dbus_message_iter_open_container (&var_iter, - DBUS_TYPE_ARRAY, - DBUS_TYPE_BYTE_AS_STRING, - &sub_array_iter)) - { - _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter); - return FALSE; - } - - if (!dbus_message_iter_append_fixed_array (&sub_array_iter, DBUS_TYPE_BYTE, - &value, value_len)) - { - dbus_message_iter_abandon_container (&var_iter, &sub_array_iter); - _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter); - return FALSE; - } - - if (!dbus_message_iter_close_container (&var_iter, &sub_array_iter)) - { - _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter); - return FALSE; - } - - if (!_dbus_asv_close_entry (arr_iter, &entry_iter, &var_iter)) - return FALSE; - - return TRUE; -} diff --git a/dbus/dbus-asv-util.h b/dbus/dbus-asv-util.h index 4c270bef..0337260a 100644 --- a/dbus/dbus-asv-util.h +++ b/dbus/dbus-asv-util.h @@ -28,23 +28,19 @@ DBUS_BEGIN_DECLS -DBusMessage *_dbus_asv_new_method_return (DBusMessage *message, - DBusMessageIter *iter, - DBusMessageIter *arr_iter); -dbus_bool_t _dbus_asv_close (DBusMessageIter *iter, - DBusMessageIter *arr_iter); -void _dbus_asv_abandon (DBusMessageIter *iter, - DBusMessageIter *arr_iter); +DBusMessage *_dbus_asv_new_method_return (DBusMessage *message, + DBusMessageIter *iter, + DBusMessageIter *arr_iter); +dbus_bool_t _dbus_asv_close (DBusMessageIter *iter, + DBusMessageIter *arr_iter); +void _dbus_asv_abandon (DBusMessageIter *iter, + DBusMessageIter *arr_iter); -dbus_bool_t _dbus_asv_add_uint32 (DBusMessageIter *arr_iter, - const char *key, - dbus_uint32_t value); -dbus_bool_t _dbus_asv_add_string (DBusMessageIter *arr_iter, - const char *key, - const char *value); +dbus_bool_t _dbus_asv_add_uint32 (DBusMessageIter *arr_iter, + const char *key, + dbus_uint32_t value); +dbus_bool_t _dbus_asv_add_string (DBusMessageIter *arr_iter, + const char *key, + const char *value); -dbus_bool_t _dbus_asv_add_array_of_bytes (DBusMessageIter *arr_iter, - const char *key, - const void *value, - unsigned int value_len); #endif diff --git a/dbus/dbus-auth.c b/dbus/dbus-auth.c index 20af83d2..6a07665f 100644 --- a/dbus/dbus-auth.c +++ b/dbus/dbus-auth.c @@ -2321,39 +2321,6 @@ _dbus_auth_client_new (void) return auth; } -/** - * 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. * diff --git a/dbus/dbus-auth.h b/dbus/dbus-auth.h index 9959b991..ba1975f7 100644 --- a/dbus/dbus-auth.h +++ b/dbus/dbus-auth.h @@ -43,7 +43,6 @@ typedef enum DBusAuth* _dbus_auth_server_new (const DBusString *guid); DBusAuth* _dbus_auth_client_new (void); -DBusAuth* _dbus_auth_client_new_authenticated (void); DBusAuth* _dbus_auth_ref (DBusAuth *auth); void _dbus_auth_unref (DBusAuth *auth); dbus_bool_t _dbus_auth_set_mechanisms (DBusAuth *auth, diff --git a/dbus/dbus-connection-internal.h b/dbus/dbus-connection-internal.h index 3553f7db..682b5bff 100644 --- a/dbus/dbus-connection-internal.h +++ b/dbus/dbus-connection-internal.h @@ -110,7 +110,6 @@ dbus_bool_t _dbus_connection_putback_message (DBusConnectio dbus_bool_t _dbus_connection_remove_message (DBusConnection *connection, DBusMessage *message); -int _dbus_connection_get_n_incoming (DBusConnection *connection); /* if DBUS_ENABLE_STATS */ void _dbus_connection_get_stats (DBusConnection *connection, diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c index 0c817aa2..618b956d 100644 --- a/dbus/dbus-connection.c +++ b/dbus/dbus-connection.c @@ -587,20 +587,8 @@ 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; @@ -2065,28 +2053,6 @@ _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); @@ -2122,6 +2088,24 @@ _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 */ @@ -2253,6 +2237,52 @@ _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 */ @@ -2495,9 +2525,9 @@ _dbus_connection_block_pending_call (DBusPendingCall *pending) { DBusMessage *error_msg; - error_msg = _dbus_generate_local_error_message (client_serial, - DBUS_ERROR_DISCONNECTED, - "Connection was disconnected before a reply was received"); + error_msg = 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); @@ -5247,16 +5277,6 @@ 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 deleted file mode 100644 index 52595ed9..00000000 --- a/dbus/dbus-marshal-gvariant.c +++ /dev/null @@ -1,1388 +0,0 @@ -/* -*- 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 */ - int i; - for (i = 0; i < value_size; i++) - { - size_t move = 8 * i; - size_t mask = 0xFF << move; - if (!_dbus_string_append_byte(str, (value & mask) >> move)) - return FALSE; - } - return TRUE; -} - -#define MAX_OFFSET_SIZE 8 -#define MAX_VALUE_FOR_OFFSET_SIZE(o) ((1ULL<<(8*(o)))-1) - -/* taken from systemd */ -static size_t -bus_gvariant_determine_word_size(size_t sz, size_t extra) -{ - if (sz + extra <= 0xFF) - return 1; - else if (sz + extra*2 <= 0xFFFF) - return 2; - else if (sz + extra*4 <= 0xFFFFFFFF) - return 4; - else - return 8; -} - -/* taken from systemd */ -static size_t -bus_gvariant_read_word_le (const void *p, size_t sz) -{ - union { - uint16_t u16; - uint32_t u32; - uint64_t u64; - } x; - - // FIXME -// assert(p); - - if (sz == 1) - return *(uint8_t*) p; - - memcpy(&x, p, sz); - - if (sz == 2) - return le16toh(x.u16); - else if (sz == 4) - return le32toh(x.u32); - else if (sz == 8) - return le64toh(x.u64); - return 0; -} - -static const char * -get_header_const_array (DBusHeader *header) -{ - return _dbus_string_get_const_data (&header->data) + FIRST_GVARIANT_FIELD_OFFSET; -} - -static size_t -get_header_array_size (DBusHeader *header) -{ - return _dbus_string_get_length (&header->data) - FIRST_GVARIANT_FIELD_OFFSET - header->padding; -} - -static dbus_bool_t -append_offsets (DBusString *str, - size_t *fields_offsets, - size_t n_fields_offsets) -{ - int i; - size_t array_size = _dbus_string_get_length (str) - FIRST_GVARIANT_FIELD_OFFSET; - size_t offset_size = bus_gvariant_determine_word_size (array_size, n_fields_offsets); - - for (i = 0; i < n_fields_offsets; i++) - { - if (!append_sized_value (str, fields_offsets[i], offset_size)) - return FALSE; - } - return TRUE; -} - -static dbus_bool_t -append_field_string (DBusString *str, - dbus_uint64_t field, - const char *value, - char type, - size_t *fields_offsets, - size_t *n_fields_offsets) -{ - dbus_bool_t res = TRUE; - if (value != NULL) - { - res = res && _dbus_string_align_length(str, 8); - res = res && append_sized_value(str, field, FIELD_ID_SIZE); - res = res && _dbus_string_append_len(str, value, strlen(value)+1); - res = res && _dbus_string_append_byte(str, 0); /* variant value-signature separator */ - res = res && _dbus_string_append_byte(str, type); - fields_offsets[(*n_fields_offsets)++] = _dbus_string_get_length(str) - FIRST_GVARIANT_FIELD_OFFSET; - } - return res; -} - -static dbus_bool_t -append_field_uint64 (DBusString *str, - dbus_uint64_t field, - dbus_uint64_t value, - size_t *fields_offsets, - size_t *n_fields_offsets) -{ - dbus_bool_t res = TRUE; - res = res && _dbus_string_align_length(str, 8); - res = res && append_sized_value(str, field, FIELD_ID_SIZE); - res = res && append_sized_value(str, value, 8); - res = res && _dbus_string_append_byte(str, 0); /* variant value-signature separator */ - res = res && _dbus_string_append_byte(str, DBUS_TYPE_UINT64); - fields_offsets[(*n_fields_offsets)++] = _dbus_string_get_length(str) - FIRST_GVARIANT_FIELD_OFFSET; - return res; -} - -static dbus_bool_t -append_field_uint32 (DBusString *str, - dbus_uint64_t field, - dbus_uint32_t value, - size_t *fields_offsets, - size_t *n_fields_offsets) -{ - dbus_bool_t res = TRUE; - res = res && _dbus_string_align_length(str, 8); - res = res && append_sized_value(str, field, FIELD_ID_SIZE); - res = res && append_sized_value(str, value, 4); - res = res && _dbus_string_append_byte(str, 0); /* variant value-signature separator */ - res = res && _dbus_string_append_byte(str, DBUS_TYPE_UINT32); - - fields_offsets[(*n_fields_offsets)++] = _dbus_string_get_length(str) - FIRST_GVARIANT_FIELD_OFFSET; - return res; -} - -static void -_dbus_header_toggle_gvariant (DBusHeader *header, dbus_bool_t gvariant) -{ - 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); - int i; - - if (get_header_array_size (header) > 0) - { - header->fields[get_field_after (array_buffer, 0)].value_pos = FIELD_ID_SIZE + FIRST_GVARIANT_FIELD_OFFSET; - for (i=0; i < n_fields_offsets-1; i++) - { - dbus_uint64_t field = get_field_after (array_buffer, fields_offsets[i]); - header->fields[field].value_pos = _DBUS_ALIGN_VALUE(fields_offsets[i],8) + - FIELD_ID_SIZE + FIRST_GVARIANT_FIELD_OFFSET; - } - } -} - -static dbus_bool_t -correct_header_padding (DBusHeader *header) -{ - int unpadded_len = _dbus_string_get_length (&header->data); - if (!_dbus_string_align_length (&header->data, 8)) - return FALSE; - - header->padding = _dbus_string_get_length (&header->data) - unpadded_len; - return TRUE; -} - -dbus_bool_t -_dbus_header_gvariant_create (DBusHeader *header, - int byte_order, - int type, - const char *destination, - const char *path, - const char *interface, - const char *member, - const char *error_name) -{ - size_t fields_offsets[DBUS_HEADER_FIELD_LAST]; - size_t n_fields_offsets = 0; - dbus_bool_t res = TRUE; - - _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN || - byte_order == DBUS_BIG_ENDIAN); - _dbus_assert (((interface || type != DBUS_MESSAGE_TYPE_SIGNAL) && member) || - (error_name) || - !(interface || member || error_name)); - _dbus_assert (_dbus_string_get_length (&header->data) == 0); - - _dbus_header_toggle_gvariant (header, TRUE); - - res = res && _dbus_string_append_byte (&header->data, byte_order); - res = res && _dbus_string_append_byte (&header->data, type); - res = res && _dbus_string_append_byte (&header->data, 0); /* flags */ - res = res && _dbus_string_append_byte (&header->data, DBUS_PROTOCOL_VERSION_GVARIANT); - res = res && append_sized_value (&header->data, 0, sizeof(dbus_uint32_t)); /* reserved */ - res = res && append_sized_value (&header->data, 0, sizeof(dbus_uint64_t)); /* cookie */ - /* array of fields */ - res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_PATH, path, DBUS_TYPE_OBJECT_PATH, - fields_offsets, &n_fields_offsets); - res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_DESTINATION, destination, DBUS_TYPE_STRING, - fields_offsets, &n_fields_offsets); - res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_INTERFACE, interface, DBUS_TYPE_STRING, - fields_offsets, &n_fields_offsets); - res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_MEMBER, member, DBUS_TYPE_STRING, - fields_offsets, &n_fields_offsets); - res = res && append_field_string (&header->data, DBUS_HEADER_FIELD_ERROR_NAME, error_name, DBUS_TYPE_STRING, - fields_offsets, &n_fields_offsets); - res = res && append_offsets (&header->data, fields_offsets, n_fields_offsets); - - _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets); - res = res && correct_header_padding (header); - - return res; -} - -static dbus_bool_t -marshal_gvariant_string (DBusString *str, - int insert_at, - const char *value, - int *pos_after, - dbus_bool_t with_nul) -{ - DBusString value_str; - size_t value_len = strlen(value); - - if (with_nul) - value_len++; - - _dbus_string_init_const_len (&value_str, value, value_len); - if (!_dbus_string_copy_len (&value_str, 0, value_len, str, insert_at)) - { - return FALSE; - } - - if (pos_after) - *pos_after = insert_at + value_len; - - return TRUE; -} - -dbus_bool_t -_dbus_marshal_write_gvariant_basic (DBusString *str, - int insert_at, - int type, - const void *value, - int byte_order, - int *pos_after) -{ - const DBusBasicValue *vp; - _dbus_assert (dbus_type_is_basic (type)); - - vp = value; - - switch (type) - { - case DBUS_TYPE_STRING: - case DBUS_TYPE_OBJECT_PATH: - case DBUS_TYPE_SIGNATURE: - return marshal_gvariant_string (str, insert_at, vp->str, pos_after, TRUE); - case DBUS_TYPE_BOOLEAN: - if (pos_after) - (*pos_after)++; - return _dbus_string_insert_byte (str, insert_at, vp->u32 != FALSE); - default: - return _dbus_marshal_write_basic (str, insert_at, type, value, byte_order, pos_after); - } -} - -void -_dbus_marshal_read_gvariant_basic (const DBusString *str, - int pos, - int type, - void *value, - int byte_order, - int *new_pos) -{ - const char *str_data; - - _dbus_assert (dbus_type_is_basic (type)); - - str_data = _dbus_string_get_const_data (str); - switch (type) - { - case DBUS_TYPE_STRING: - case DBUS_TYPE_OBJECT_PATH: - case DBUS_TYPE_SIGNATURE: - { - volatile char **vp = value; - *vp = (char*) str_data + pos; - pos += strlen (str_data+pos)+1; - } - break; - case DBUS_TYPE_BOOLEAN: - { - volatile dbus_bool_t *vp = value; - *vp = (dbus_bool_t) _dbus_string_get_byte (str, pos); - (pos)++; - } - break; - default: - _dbus_marshal_read_basic (str, pos, type, value, byte_order, new_pos); - break; - } - - if (new_pos) - *new_pos = pos; -} - -static void -get_offsets (const char *buffer, size_t container_size, - size_t *fields_offsets, size_t *n_fields_offsets, - size_t *offset_size) -{ - *offset_size = bus_gvariant_determine_word_size (container_size, 0); - - if (0 < container_size && 0 < *offset_size) - { - size_t last_offset_position = container_size - (*offset_size); - size_t last_offset = bus_gvariant_read_word_le (buffer + last_offset_position, - (*offset_size)); - int i; - - *n_fields_offsets = (container_size - last_offset) / (*offset_size); - fields_offsets[(*n_fields_offsets)-1] = last_offset; - for (i = 0; i < (*n_fields_offsets)-1; i++) - { - fields_offsets[i] = bus_gvariant_read_word_le (buffer + last_offset + i*(*offset_size), - (*offset_size)); - } - } -} - -static int -find_field (int field, const char *array_buffer, size_t *fields_offsets, size_t n_fields_offsets, - size_t *field_offset) -{ - /* last_offset points to the offsets array, beyond the last element of the array container */ - size_t last_offset = fields_offsets[n_fields_offsets-1]; - int i = 0; - size_t next_offset = 0; - - while ( next_offset < last_offset && get_field_after (array_buffer, next_offset) != field) - { - next_offset = fields_offsets[i]; - i++; - } - if (next_offset < last_offset) - { - *field_offset = next_offset; - return i; - } - return -1; -} - -dbus_bool_t -_dbus_header_gvariant_delete_field (DBusHeader *header, - int field) -{ - size_t fields_offsets[DBUS_HEADER_FIELD_LAST]; - size_t n_fields_offsets = 0; - size_t offset_size = 0; - const char *array_buffer; - - _dbus_assert(field <= DBUS_HEADER_FIELD_LAST); - - array_buffer = get_header_const_array (header); - - get_offsets (array_buffer, - get_header_array_size (header), - fields_offsets, &n_fields_offsets, &offset_size ); - - if (0 < n_fields_offsets) - { - /* check if the field is already in the header */ - size_t field_offset; - int field_index = find_field (field, array_buffer, fields_offsets, n_fields_offsets, &field_offset); - - /* prepare for changing - remove array offsets and offsets */ - _dbus_string_shorten (&header->data, n_fields_offsets*offset_size + header->padding); - - if (field_index >= 0) - { - /* field exists */ - size_t field_len = 0; - size_t field_start = 0; - /* let's remove aligned block of the field, along with padding */ - if (field_index == 0) - { - field_len = _DBUS_ALIGN_VALUE (fields_offsets[0],8); - } - else - { - field_len = _DBUS_ALIGN_VALUE (fields_offsets[field_index],8) - - _DBUS_ALIGN_VALUE (fields_offsets[field_index-1],8); - } - - field_start = FIRST_GVARIANT_FIELD_OFFSET + _DBUS_ALIGN_VALUE (field_offset, 8); - - /* if this is the last field, then there is no padding at the end */ - if (field_start + field_len > _dbus_string_get_length (&header->data)) - { - field_len = _dbus_string_get_length (&header->data) - field_start; - } - - /* remove the field */ - _dbus_string_delete (&header->data, field_start, field_len); - header->fields[field].value_pos = _DBUS_HEADER_FIELD_VALUE_NONEXISTENT; - /* and update offsets */ - for (; field_index < n_fields_offsets-1; field_index++) - { - fields_offsets[field_index] = fields_offsets[field_index+1]-field_len; - } - n_fields_offsets--; - - /* remove padding from now-last field */ - _dbus_string_shorten (&header->data, - _dbus_string_get_length(&header->data) - - (FIRST_GVARIANT_FIELD_OFFSET + fields_offsets[n_fields_offsets-1])); - header->padding = 0; - } - } - - /* It seems impossible for append_offsets() and correct_header_padding() to fail, - because space for offsets was already allocated */ - if (!append_offsets(&header->data, fields_offsets, n_fields_offsets)) - return FALSE; - _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets); - if (!correct_header_padding (header)) - return FALSE; - - return TRUE; -} - -dbus_bool_t -_dbus_header_set_field_basic_gvariant (DBusHeader *header, - int field, - int type, - const void *value) -{ - size_t fields_offsets[DBUS_HEADER_FIELD_LAST]; - size_t n_fields_offsets = 0; - dbus_bool_t result = TRUE; - const DBusBasicValue *vp = value; - size_t offset_size = 0; - const char *array_buffer; - - _dbus_assert(field != DBUS_HEADER_FIELD_INVALID); - _dbus_assert(field <= DBUS_HEADER_FIELD_LAST); - - array_buffer = get_header_const_array (header); - - result = result && _dbus_header_gvariant_delete_field (header, field); - - /* now, we are sure that there is no such field (anymore) - so, simply append */ - - get_offsets (array_buffer, - get_header_array_size (header), - fields_offsets, &n_fields_offsets, &offset_size ); - - /* prepare for changing - remove array offsets and padding */ - _dbus_string_shorten (&header->data, n_fields_offsets*offset_size + header->padding); - - switch (type) - { - case DBUS_TYPE_STRING: - case DBUS_TYPE_OBJECT_PATH: - case DBUS_TYPE_SIGNATURE: - result = result && append_field_string (&header->data, field, vp->str, type, - fields_offsets, &n_fields_offsets); - break; - case DBUS_TYPE_UINT32: - result = result && append_field_uint32 (&header->data, field, vp->u32, - fields_offsets, &n_fields_offsets); - break; - case DBUS_TYPE_UINT64: - append_field_uint64 (&header->data, field, vp->u64, - fields_offsets, &n_fields_offsets); - result = TRUE; - break; - default: - _dbus_assert_not_reached("Not a basic type"); - result = FALSE; - break; - } - - result = result && append_offsets(&header->data, fields_offsets, n_fields_offsets); - _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets); - result = result && correct_header_padding (header); - - return result; -} - -dbus_bool_t -_dbus_header_get_field_basic_gvariant (DBusHeader *header, - int field, - int type, - void *value) -{ - size_t fields_offsets[DBUS_HEADER_FIELD_LAST]; - size_t n_fields_offsets = 0; - dbus_bool_t result = FALSE; - DBusBasicValue *vp = value; - size_t offset_size = 0; - const char *array_buffer; - - _dbus_assert(field != DBUS_HEADER_FIELD_INVALID); - _dbus_assert(field <= DBUS_HEADER_FIELD_LAST); - - array_buffer = get_header_const_array (header); - - get_offsets( array_buffer, - get_header_array_size (header), - fields_offsets, &n_fields_offsets, &offset_size ); - - if (0 < n_fields_offsets) - { - /* check if the field is already in the header */ - size_t field_offset; - int field_index = find_field (field, array_buffer, fields_offsets, n_fields_offsets, &field_offset); - if (0 <= field_index) - { - /* field found, get value */ - const void *field_begin = array_buffer + _DBUS_ALIGN_VALUE(field_offset,8) + FIELD_ID_SIZE; - dbus_uint32_t byte_order = _dbus_header_get_byte_order (header); - - switch (type) - { - case DBUS_TYPE_STRING: - case DBUS_TYPE_OBJECT_PATH: - case DBUS_TYPE_SIGNATURE: - { - vp->str = (char *)field_begin; - } - break; - case DBUS_TYPE_UINT32: - { - vp->u32 = *(const dbus_uint32_t *)field_begin; - if (byte_order != DBUS_COMPILER_BYTE_ORDER) - vp->u32 = DBUS_UINT32_SWAP_LE_BE (vp->u32); - } - break; - case DBUS_TYPE_UINT64: - { - vp->u64 = *(const dbus_uint64_t *)field_begin; - if (byte_order != DBUS_COMPILER_BYTE_ORDER) - vp->u64 = DBUS_UINT64_SWAP_LE_BE (vp->u64); - } - break; - default: - _dbus_assert_not_reached("Not a basic type"); - break; - } - - result = TRUE; - } - } - return result; -} - -void -_dbus_marshal_skip_gvariant_basic (const DBusString *str, - int type, - int byte_order, - int *pos) -{ - switch (type) - { - case DBUS_TYPE_STRING: - case DBUS_TYPE_OBJECT_PATH: - case DBUS_TYPE_SIGNATURE: - /* FIXME - this will require redesign... size should come from upper container */ - *pos += strlen (_dbus_string_get_const_data (str) + *pos) + 1; /* length plus nul */ - break; - case DBUS_TYPE_BOOLEAN: - (*pos)++; - break; - default: - _dbus_marshal_skip_basic (str, type, byte_order, pos); - break; - } -} - -dbus_bool_t -_dbus_header_load_gvariant (DBusHeader *header, - DBusTypeReader *reader, - DBusValidity *validity) -{ - size_t fields_offsets[DBUS_HEADER_FIELD_LAST]; - size_t n_fields_offsets = 0; - size_t offset_size = 0; - const char *array_buffer = get_header_const_array (header); - - get_offsets( array_buffer, - get_header_array_size (header), - fields_offsets, &n_fields_offsets, &offset_size ); - - _dbus_header_fill_cache (header, fields_offsets, n_fields_offsets); - return TRUE; -} - -dbus_bool_t -_dbus_gvariant_raw_get_lengths (const DBusString *str, - dbus_uint32_t *fields_array_len_unsigned, - dbus_uint32_t *body_len_unsigned, - DBusValidity *validity) -{ - size_t message_len = _dbus_string_get_length (str); - size_t body_offsets_size = bus_gvariant_determine_word_size (message_len, 0); - const char *message_ptr = _dbus_string_get_const_data (str); - /* so, the offset of end of fields is written at offset str->len - body_offsets_size */ - size_t end_of_fields = bus_gvariant_read_word_le (message_ptr + message_len - body_offsets_size, - body_offsets_size); - *fields_array_len_unsigned = end_of_fields - FIRST_GVARIANT_FIELD_OFFSET; - - *body_len_unsigned = message_len - _DBUS_ALIGN_VALUE (end_of_fields, 8); - return TRUE; -} - -DBusValidity -_dbus_validate_gvariant_body_with_reason (const DBusString *expected_signature, - int expected_signature_start, - int byte_order, - int *bytes_remaining, - const DBusString *value_str, - int value_pos, - int len) -{ - /* FIXME stub */ - if (bytes_remaining) - *bytes_remaining = 0; - return DBUS_VALID; -} - -dbus_bool_t -_dbus_message_gvariant_get_signature (DBusMessage *message, - const DBusString **type_str_p, - int *type_pos_p, - int *type_str_len) -{ - size_t body_len = _dbus_string_get_length (&message->body); - size_t message_len = _dbus_string_get_length (&message->header.data) + body_len; - size_t body_offsets_size = bus_gvariant_determine_word_size (message_len, 0); - const char *body_ptr = _dbus_string_get_const_data (&message->body); - const char *sig_end_ptr = body_ptr + body_len - body_offsets_size; - const char *sig_ptr = sig_end_ptr - 1; - - while (sig_ptr >= body_ptr && (*sig_ptr) != 0) - { - sig_ptr--; - } - - if (sig_ptr < body_ptr) - return FALSE; - - if (type_str_p != NULL) - *type_str_p = &message->body; - *type_pos_p = sig_ptr - body_ptr + 1; - *type_str_len = sig_end_ptr - sig_ptr - 1; - - return TRUE; -} - -dbus_bool_t -_dbus_message_append_body_offset (DBusMessage *message) -{ - size_t body_len = _dbus_string_get_length (&message->body); - size_t end_of_fields_offset = _dbus_string_get_length (&message->header.data) - message->header.padding; - size_t message_len = _dbus_string_get_length (&message->header.data) + body_len; - size_t body_offsets_size = bus_gvariant_determine_word_size (message_len, 1); - - return append_sized_value (&message->body, end_of_fields_offset, body_offsets_size); -} - -dbus_bool_t -_dbus_message_gvariant_add_signature (DBusMessage *message, - const DBusString *type_str) -{ - dbus_bool_t res = _dbus_string_append_byte (&message->body, 0); - res = res && _dbus_string_append_byte (&message->body, '('); - res = res && marshal_gvariant_string (&message->body, _dbus_string_get_length (&message->body), - _dbus_string_get_const_data (type_str), NULL, FALSE); - res = res && _dbus_string_append_byte (&message->body, ')'); - return res; -} - -dbus_bool_t -_dbus_message_gvariant_remove_body_offset (DBusMessage *message) -{ - size_t offset_size = bus_gvariant_determine_word_size (_dbus_string_get_length (&message->header.data) + - _dbus_string_get_length (&message->body), - 0); - _dbus_string_shorten (&message->body, offset_size); - return TRUE; -} - -dbus_bool_t -_dbus_message_finalize_gvariant (DBusMessage *message, dbus_bool_t remove_signature_from_header) -{ - DBusString str; - const DBusString *type_str; - int type_pos; - dbus_bool_t fieldSignaturePresent; - dbus_bool_t res = TRUE; - - _dbus_assert (!message->locked); - - if (message->header.protocol_version != DBUS_PROTOCOL_VERSION_GVARIANT) - return TRUE; - - fieldSignaturePresent = _dbus_header_get_field_raw (&message->header, - DBUS_HEADER_FIELD_SIGNATURE, - &type_str, - &type_pos); - if (fieldSignaturePresent) - { - /* if there is signature field, then we need to move this signature to body, - * and delete the field - */ - const char *sig_ptr = _dbus_string_get_const_data (type_str) + type_pos; - _dbus_string_init_const (&str, sig_ptr); - } - else - { - /* If there is no signature field, then the body is empty. - * However, we need to add signature anyway, because body is a variant. - */ - _dbus_string_init_const (&str, ""); - type_str = &str; - type_pos = 0; - /* Let's set the body also */ - _dbus_string_set_length (&message->body, 0); - _dbus_string_append_byte (&message->body, 0); - } - - res = res && _dbus_message_gvariant_add_signature (message, &str); - - if (res && fieldSignaturePresent && remove_signature_from_header) - res = res && _dbus_header_gvariant_delete_field (&message->header, DBUS_HEADER_FIELD_SIGNATURE); - - res = res && _dbus_message_append_body_offset (message); - - return res; -} - -/* returns length of the body inside the outermost variant - * that is, without offset and signature from the end of messages - */ -static size_t -_dbus_message_gvariant_get_body_length (DBusMessage *message) -{ - size_t body_len = _dbus_string_get_length (&message->body); - size_t message_len = body_len + _dbus_string_get_length (&message->header.data); - body_len -= bus_gvariant_determine_word_size (message_len , 0); - - while (body_len > 0 && _dbus_string_get_byte (&message->body, body_len) != 0) - body_len--; - - return body_len; -} - -static inline int -get_max (int a, int b) -{ - return (a>b) ? a : b; -} - -static int -update_size (int current_size, int size_of_element, int *alignment, int new_alignment) -{ - *alignment = get_max (*alignment, new_alignment); - current_size = _DBUS_ALIGN_VALUE (current_size, *alignment); - return current_size + size_of_element; -} - -static int -_dbus_reader_get_signature_fixed_size (const DBusString *signature, int *pos, int *alignment) -{ - int res = 0; - int depth = 0; - int current_alignment = 1; - dbus_bool_t variable = FALSE; - - char c = _dbus_string_get_byte (signature, *pos); - if (c == DBUS_STRUCT_BEGIN_CHAR || c == DBUS_DICT_ENTRY_BEGIN_CHAR) - { - depth = 1; - (*pos)++; - } - - do { - switch (_dbus_string_get_byte (signature, *pos)) - { - case DBUS_TYPE_BYTE: - case DBUS_TYPE_BOOLEAN: - res += 1; - break; - case DBUS_TYPE_INT16: - case DBUS_TYPE_UINT16: - res = update_size (res, 2, ¤t_alignment, 2); - break; - case DBUS_TYPE_INT32: - case DBUS_TYPE_UINT32: - case DBUS_TYPE_UNIX_FD: - res = update_size (res, 4, ¤t_alignment, 4); - break; - case DBUS_TYPE_INT64: - case DBUS_TYPE_UINT64: - case DBUS_TYPE_DOUBLE: - res = update_size (res, 8, ¤t_alignment, 8); - break; - case DBUS_STRUCT_END_CHAR: - case DBUS_DICT_ENTRY_END_CHAR: - depth--; - break; - case DBUS_STRUCT_BEGIN_CHAR: - case DBUS_DICT_ENTRY_BEGIN_CHAR: - { - int alignment_recursive; - int res_recursive = _dbus_reader_get_signature_fixed_size (signature, pos, &alignment_recursive); - if (res_recursive == 0) - variable = TRUE; /* variable size detected */ - - /* we need to update at least alignment */ - res = update_size (res, res_recursive, ¤t_alignment, alignment_recursive); - } - break; - case DBUS_TYPE_VARIANT: - current_alignment = 8; - variable = TRUE; - break; - case DBUS_TYPE_ARRAY: - { - int alignment_recursive; - int recursive_pos = *pos + 1; - int res_recursive = _dbus_reader_get_signature_fixed_size (signature, &recursive_pos, &alignment_recursive); - - variable = TRUE; /* variable size detected */ - - /* we need to update alignment */ - res = update_size (res, res_recursive, ¤t_alignment, alignment_recursive); - - /* and update position */ - *pos = recursive_pos - 1; - } - break; - default: - variable = TRUE; /* variable size detected */ - } - (*pos)++; - } while (depth > 0); - - /* we want to point it to the last character, to allow upper instance to skip it */ - (*pos)--; - - if (alignment != NULL) - *alignment = current_alignment; - - return variable ? 0 : res; -} - -int -_dbus_reader_get_type_fixed_size (DBusTypeReader *reader, int *alignment) -{ - int pos = reader->type_pos; - return _dbus_reader_get_signature_fixed_size (reader->type_str, &pos, alignment); -} - -int -_dbus_type_gvariant_get_fixed_size (const DBusString *type_str, int type_pos, int *alignment) -{ - return _dbus_reader_get_signature_fixed_size (type_str, &type_pos, alignment); -} - -/* This is for structs and dict entries. - * Counts variable elements inside a container. - * This is equal to number of offsets embedded into the container. - */ -int -_dbus_reader_count_offsets (const DBusTypeReader *reader) -{ - DBusTypeReader r; - int variables = 0; - dbus_bool_t prev_is_variable = FALSE; - int current_type; - int ending_char; - - /* if signature is not empty, it must be after initial parenthesis */ - /* empty signature has length 1 - only nul byte */ - _dbus_assert (reader->type_pos > 0); - - _dbus_type_reader_init_types_only (&r, - reader->type_str, - reader->type_pos); - r.gvariant = TRUE; - r.klass = reader->klass; - - /* Check what container we're in */ - switch (_dbus_string_get_byte (r.type_str, r.type_pos-1)) - { - case DBUS_STRUCT_BEGIN_CHAR: - ending_char = DBUS_STRUCT_END_CHAR; - break; - case DBUS_DICT_ENTRY_BEGIN_CHAR: - ending_char = DBUS_DICT_ENTRY_END_CHAR; - break; - default: - _dbus_assert_not_reached ("function must be called inside structs or dict entries"); - break; - } - r.finished = (_dbus_string_get_byte (r.type_str, r.type_pos) == ending_char); - - while ((current_type = _dbus_type_reader_get_current_type (&r)) != DBUS_TYPE_INVALID) - { - int size = _dbus_reader_get_type_fixed_size (&r, NULL); - if (prev_is_variable) - variables++; - prev_is_variable = (size == 0); - _dbus_type_signature_next (_dbus_string_get_const_data(r.type_str), &r.type_pos); - r.finished = (_dbus_string_get_byte (r.type_str, r.type_pos) == ending_char); - } - return variables; -} - -size_t -_dbus_reader_get_offset_of_end_of_variable (DBusTypeReader *reader) -{ - if (reader->is_variant) - { - /* variant has its end set to the separating 0 */ - return reader->value_end; - } - else - { - const char *buffer = _dbus_string_get_const_data (reader->value_str) + reader->value_start; - size_t container_size = reader->value_end - reader->value_start; - size_t offset_size = bus_gvariant_determine_word_size (container_size, 0); - int index_from_back = reader->offsets_from_back ? - reader->variable_index : - reader->n_offsets - 1 - reader->variable_index; - - if (0 < container_size && 0 <= index_from_back) - { - size_t required_offset_position = container_size - (index_from_back+1)*offset_size; - if (index_from_back < reader->n_offsets) - return reader->value_start + - bus_gvariant_read_word_le (buffer + required_offset_position, - offset_size); - else if (reader->offsets_from_back) - return reader->value_start + - container_size - (reader->n_offsets * offset_size); /* this is end of internal container */ - } - } - - return reader->value_start; -} - -int -_dbus_reader_count_array_elems (const DBusTypeReader *reader) -{ - const char *buffer = _dbus_string_get_const_data (reader->value_str) + reader->value_start; - size_t container_size = reader->value_end - reader->value_start; - size_t offset_size = bus_gvariant_determine_word_size (container_size, 0); - size_t last_offset = bus_gvariant_read_word_le (buffer + container_size - offset_size, offset_size); - return (container_size - last_offset) / offset_size; -} - -static dbus_bool_t -write_offset (DBusString *offsets, - size_t offset, - size_t offset_size, - int insert_at) -{ - DBusString str; - dbus_bool_t res = _dbus_string_init_preallocated (&str, offset_size); - res = res && append_sized_value (&str, offset, offset_size); - res = res && _dbus_string_copy_len (&str, 0, offset_size, offsets, insert_at); - _dbus_string_free (&str); - return res; -} - -static dbus_bool_t -prepend_offset (DBusString *offsets, - size_t offset, - size_t offset_size) -{ - return write_offset (offsets, offset, offset_size, 0); -} - -static dbus_bool_t -append_offset (DBusString *offsets, - size_t offset, - size_t offset_size) -{ - return write_offset (offsets, offset, offset_size, _dbus_string_get_length(offsets)); -} - -static dbus_bool_t -convert_offsets (DBusString *offsets, - size_t old_offsets_size, - size_t new_offsets_size) -{ - char *old_offsets = NULL; - size_t n_offsets = _dbus_string_get_length (offsets) / old_offsets_size; - dbus_bool_t result = _dbus_string_steal_data (offsets, &old_offsets); - int i; - - for (i = 0; i < n_offsets && result; i++) - { - size_t offset = bus_gvariant_read_word_le (old_offsets + i*old_offsets_size, old_offsets_size); - result = result && append_sized_value (offsets, offset, new_offsets_size); - } - - dbus_free (old_offsets); - - return result; -} - -static size_t -get_offsets_count (DBusString *offsets, size_t offsets_size) -{ - return _dbus_string_get_length (offsets) / offsets_size; -} - -static dbus_bool_t -check_offsets_for_adding (DBusTypeWriter *writer) -{ - size_t container_size = writer->value_pos - writer->value_start; - size_t n_offsets = get_offsets_count (writer->offsets, - writer->offsets_size); - size_t offsets_size = bus_gvariant_determine_word_size (container_size, n_offsets + 1); - if (offsets_size != writer->offsets_size) - { - if (!convert_offsets (writer->offsets, writer->offsets_size, offsets_size)) - return FALSE; - writer->offsets_size = offsets_size; - } - return TRUE; -} - -static dbus_bool_t -convert_offsets_in_body (DBusTypeWriter *writer, - size_t new_offsets_size) -{ - DBusString offsets; - size_t n_offsets; - int i; - dbus_bool_t result = _dbus_string_init (&offsets); - char *old_offsets; - - result = result && _dbus_string_move (writer->value_str, writer->value_pos, &offsets, 0); - n_offsets = _dbus_string_get_length (&offsets) / writer->offsets_size; - old_offsets = _dbus_string_get_data (&offsets); - - for (i = 0; i < n_offsets && result; i++) - { - size_t offset = bus_gvariant_read_word_le (old_offsets + i*writer->offsets_size, writer->offsets_size); - result = result && append_sized_value (writer->value_str, offset, new_offsets_size); - } - - _dbus_string_free (&offsets); - return result; -} - -static dbus_bool_t -check_offsets_in_body_for_adding (DBusTypeWriter *writer) -{ - size_t container_size = writer->value_pos - writer->value_start; - size_t n_offsets = (_dbus_string_get_length (writer->value_str) - writer->value_pos) / writer->offsets_size; - size_t offsets_size = bus_gvariant_determine_word_size (container_size, n_offsets + 1); - if (offsets_size != writer->offsets_size) - { - if (!convert_offsets_in_body (writer, offsets_size)) - return FALSE; - writer->offsets_size = offsets_size; - } - return TRUE; -} - -static dbus_bool_t -_dbus_writer_gvariant_add_offset_with_variability (DBusTypeWriter *writer, - dbus_bool_t fixed) -{ - writer->is_fixed = writer->is_fixed && fixed; - - if (writer->body_container || - DBUS_TYPE_STRUCT == writer->container_type || - DBUS_TYPE_DICT_ENTRY == writer->container_type) - { - if (writer->u.struct_or_dict.last_offset != 0) - { - if (writer->body_container) - { - check_offsets_in_body_for_adding (writer); - - write_offset (writer->value_str, - writer->u.struct_or_dict.last_offset, - writer->offsets_size, - writer->value_pos); - } - else - { - check_offsets_for_adding (writer); - - prepend_offset (writer->offsets, - writer->u.struct_or_dict.last_offset, - writer->offsets_size); - } - } - if (!fixed) - { - writer->u.struct_or_dict.last_offset = writer->value_pos - writer->value_start; - } - else - { - writer->u.struct_or_dict.last_offset = 0; - } - } - else if (DBUS_TYPE_ARRAY == writer->container_type) - { - if (writer->offsets_size > 0) - { - check_offsets_for_adding (writer); - - if (!append_offset (writer->offsets, - writer->value_pos - writer->value_start, - writer->offsets_size)) - return FALSE; - } - } - return TRUE; -} - -static dbus_bool_t -_dbus_writer_gvariant_add_offset (DBusTypeWriter *writer, - int type) -{ - return _dbus_writer_gvariant_add_offset_with_variability (writer, dbus_type_is_fixed (type)); -} - -/* this function gets only known alignments - other are 1 */ -static int -get_alignment (int type) -{ - switch (type) - { - case DBUS_TYPE_INT16: - case DBUS_TYPE_UINT16: - return 2; - case DBUS_TYPE_INT32: - case DBUS_TYPE_UINT32: - case DBUS_TYPE_UNIX_FD: - return 4; - case DBUS_TYPE_INT64: - case DBUS_TYPE_UINT64: - case DBUS_TYPE_DOUBLE: - case DBUS_TYPE_VARIANT: - return 8; - default: - break; - } - return 1; -} - -static dbus_bool_t -fix_struct_alignment_value (DBusTypeWriter *writer, int alignment) -{ - dbus_bool_t result = TRUE; - int old_alignment = writer->alignment; - if (old_alignment < alignment) - { - int diff = _DBUS_ALIGN_VALUE (writer->value_start, alignment) - writer->value_start; - result = _dbus_string_insert_bytes (writer->value_str, writer->value_start, diff, 0); - writer->value_start += diff; - writer->value_pos += diff; - writer->alignment = alignment; - } - return result; -} - -static dbus_bool_t -fix_struct_alignment (DBusTypeWriter *writer, int type) -{ - return fix_struct_alignment_value (writer, get_alignment (type)); -} - -dbus_bool_t -_dbus_type_writer_gvariant_write_basic_no_typecode (DBusTypeWriter *writer, - int type, - const void *value) -{ - dbus_bool_t result = TRUE; - - if (writer->container_type == DBUS_TYPE_STRUCT || writer->container_type == DBUS_TYPE_DICT_ENTRY) - result = fix_struct_alignment (writer, type); - - result = result && _dbus_marshal_write_gvariant_basic (writer->value_str, - writer->value_pos, - type, - value, - writer->byte_order, - &writer->value_pos); - - result = result && _dbus_writer_gvariant_add_offset (writer, type); - return result; -} - -static dbus_bool_t -write_offsets (DBusString *dest, size_t insert_at, DBusString *offsets) -{ - return _dbus_string_copy (offsets, 0, dest, insert_at); -} - -dbus_bool_t -_dbus_writer_unrecurse_gvariant_write (DBusTypeWriter *writer, - DBusTypeWriter *sub) -{ - dbus_bool_t result = TRUE; - - if (writer->alignment < sub->alignment) - writer->alignment = sub->alignment; - - switch (sub->container_type) { - case DBUS_TYPE_STRUCT: - case DBUS_TYPE_DICT_ENTRY: - { - int diff; - int sub_len; - - if (NULL != sub->offsets) - { - write_offsets (sub->value_str, sub->value_pos, sub->offsets); - - _dbus_string_free (sub->offsets); - dbus_free (sub->offsets); - } - - diff = _DBUS_ALIGN_VALUE (writer->value_pos, sub->alignment) - writer->value_pos; - - result = _dbus_string_insert_bytes (writer->value_str, writer->value_pos, diff, 0); - writer->value_pos += diff; - sub_len = _dbus_string_get_length (sub->value_str); - result = result && _dbus_string_copy_len (sub->value_str, 0, - sub_len, - writer->value_str, - writer->value_pos); - writer->value_pos += sub_len; - - _dbus_string_free (sub->value_str); - dbus_free (sub->value_str); - - break; - } - case DBUS_TYPE_VARIANT: - { - int sub_type_len; - - /* write separating nul byte */ - result = _dbus_string_insert_byte (sub->value_str, sub->value_pos, 0); - sub->value_pos += 1; - - /* write signature */ - sub_type_len = _dbus_string_get_length (sub->type_str); - result = result && _dbus_string_copy_len (sub->type_str, 0, - sub_type_len, - sub->value_str, - sub->value_pos); - sub->value_pos += sub_type_len; - - /* free type string allocated in writer_recurse_variant() */ - _dbus_string_free (sub->type_str); - dbus_free (sub->type_str); - - /* update parent's string pointer */ - writer->value_pos = sub->value_pos; - - break; - } - case DBUS_TYPE_ARRAY: - writer->value_pos = sub->value_pos; - if (NULL != sub->offsets) - { - write_offsets (sub->value_str, sub->value_pos, sub->offsets); - - writer->value_pos += _dbus_string_get_length (sub->offsets); - - _dbus_string_free (sub->offsets); - dbus_free (sub->offsets); - } - - break; - default: - _dbus_assert_not_reached("Invalid container type"); - } - - /* well, we don't know where in the type string beginning of current container is */ - result = result && _dbus_writer_gvariant_add_offset_with_variability (writer, sub->is_fixed); - - return result; -} - -void -_dbus_type_reader_gvariant_init (DBusTypeReader *reader, - DBusMessage *message) -{ - reader->gvariant = TRUE; - /* GVariant wraps contents into struct */ - if (_dbus_string_get_byte (reader->type_str, reader->type_pos) == DBUS_STRUCT_BEGIN_CHAR) - { - reader->type_pos++; - if (_dbus_string_get_byte (reader->type_str, reader->type_pos) == DBUS_STRUCT_END_CHAR) - reader->finished = TRUE; - } - - reader->value_end = _dbus_message_gvariant_get_body_length (message); - reader->n_offsets = _dbus_reader_count_offsets (reader); -} diff --git a/dbus/dbus-marshal-gvariant.h b/dbus/dbus-marshal-gvariant.h deleted file mode 100644 index 79d23a0a..00000000 --- a/dbus/dbus-marshal-gvariant.h +++ /dev/null @@ -1,132 +0,0 @@ -/* -*- 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 bd98a12d..48151c62 100644 --- a/dbus/dbus-marshal-header.c +++ b/dbus/dbus-marshal-header.c @@ -27,9 +27,6 @@ #include "dbus-marshal-recursive.h" #include "dbus-marshal-byteswap.h" -#include "dbus-protocol-gvariant.h" -#include "dbus-marshal-gvariant.h" - /** * @addtogroup DBusMarshal * @@ -126,12 +123,6 @@ 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 @@ -424,11 +415,6 @@ _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)); } /** @@ -527,7 +513,6 @@ _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 @@ -693,16 +678,13 @@ _dbus_header_have_message_untrusted (int max_message_length, int *body_len, const DBusString *str, int start, - int len, - dbus_bool_t *is_gvariant) + int len) { 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); @@ -717,32 +699,9 @@ _dbus_header_have_message_untrusted (int max_message_length, return FALSE; } - 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; - } + _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); if (fields_array_len_unsigned > (unsigned) max_message_length) { @@ -750,6 +709,10 @@ _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; @@ -977,86 +940,6 @@ 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 @@ -1098,11 +981,13 @@ _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); @@ -1114,14 +999,6 @@ _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) { @@ -1129,20 +1006,10 @@ _dbus_header_load (DBusHeader *header, } else { - 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); - } + v = _dbus_validate_body_with_reason (&_dbus_header_signature_str, 0, + byte_order, + &leftover, + str, start, len); if (v != DBUS_VALID) { @@ -1181,7 +1048,7 @@ _dbus_header_load (DBusHeader *header, _dbus_type_reader_init (&reader, byte_order, - signature, 0, + &_dbus_header_signature_str, 0, str, start); /* BYTE ORDER */ @@ -1223,25 +1090,75 @@ _dbus_header_load (DBusHeader *header, if (v_byte != DBUS_MAJOR_PROTOCOL_VERSION) { - if (v_byte == DBUS_PROTOCOL_VERSION_GVARIANT) - { - reader.gvariant = TRUE; - } - else - { - *validity = DBUS_INVALID_BAD_PROTOCOL_VERSION; - goto invalid; - } + *validity = DBUS_INVALID_BAD_PROTOCOL_VERSION; + goto invalid; } - if (reader.gvariant) + + /* 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 (!_dbus_header_load_gvariant (header, &reader, validity)) - goto invalid; + *validity = DBUS_INVALID_BAD_SERIAL; + goto invalid; } - else + + _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) { - if (!_dbus_header_load_dbus1 (header, &reader, validity, body_len)) - goto invalid; + 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); } /* Anything we didn't fill in is now known not to exist */ @@ -1341,8 +1258,19 @@ find_field_for_modification (DBusHeader *header, return retval; } -static dbus_bool_t -_dbus_header_set_field_basic_dbus1 (DBusHeader *header, +/** + * 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, int field, int type, const void *value) @@ -1410,29 +1338,17 @@ _dbus_header_set_field_basic_dbus1 (DBusHeader *header, } /** - * 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. + * 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 set + * @param field the field to get * @param type the type of the value - * @param value the value as for _dbus_marshal_set_basic() - * @returns #FALSE if no memory + * @param value the value as for _dbus_marshal_read_basic() + * @returns #FALSE if the field doesn't exist */ dbus_bool_t -_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, +_dbus_header_get_field_basic (DBusHeader *header, int field, int type, void *value) @@ -1458,26 +1374,6 @@ _dbus_header_get_field_basic_dbus1 (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 4ff986c9..350fe5c4 100644 --- a/dbus/dbus-marshal-header.h +++ b/dbus/dbus-marshal-header.h @@ -57,7 +57,6 @@ 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); @@ -109,8 +108,7 @@ dbus_bool_t _dbus_header_have_message_untrusted (int max_messag int *body_len, const DBusString *str, int start, - int len, - dbus_bool_t *is_gvariant); + int len); 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 8a5c90e1..4adfd2e9 100644 --- a/dbus/dbus-marshal-recursive.c +++ b/dbus/dbus-marshal-recursive.c @@ -2,7 +2,6 @@ /* 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 * @@ -27,7 +26,6 @@ #include "dbus-marshal-basic.h" #include "dbus-signature.h" #include "dbus-internals.h" -#include "dbus-marshal-gvariant.h" /** * @addtogroup DBusMarshal @@ -149,8 +147,7 @@ reader_init (DBusTypeReader *reader, const DBusString *type_str, int type_pos, const DBusString *value_str, - int value_pos, - dbus_bool_t gvariant) + int value_pos) { reader->byte_order = byte_order; reader->finished = FALSE; @@ -158,11 +155,6 @@ 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 @@ -175,8 +167,7 @@ base_reader_recurse (DBusTypeReader *sub, parent->type_str, parent->type_pos, parent->value_str, - parent->value_pos, - parent->gvariant); + parent->value_pos); } static void @@ -199,31 +190,8 @@ struct_or_dict_entry_reader_recurse (DBusTypeReader *sub, { struct_or_dict_entry_types_only_reader_recurse (sub, parent); - 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); - } + /* struct and dict entry have 8 byte alignment */ + sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8); } static void @@ -251,9 +219,6 @@ 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); @@ -279,38 +244,20 @@ array_reader_recurse (DBusTypeReader *sub, array_types_only_reader_recurse (sub, parent); - 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); + 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", @@ -332,46 +279,21 @@ variant_reader_recurse (DBusTypeReader *sub, base_reader_recurse (sub, parent); - 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); - - /* find beginning of signature in variant */ - sub->type_str = sub->value_str; - sub->type_pos = sub->value_end - 1; - - while (sub->type_pos > 0 && _dbus_string_get_byte (sub->type_str, sub->type_pos) != 0) - sub->type_pos--; - - if (_dbus_string_get_byte (sub->type_str, sub->type_pos) == 0) - sub->type_pos++; - - /* 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); + /* Variant is 1 byte sig length (without nul), signature with nul, + * padding to 8-boundary, then values + */ - sub->type_str = sub->value_str; - sub->type_pos = sub->value_pos + 1; + sig_len = _dbus_string_get_byte (sub->value_str, sub->value_pos); - sub->value_pos = sub->type_pos + sig_len + 1; + sub->type_str = sub->value_str; + sub->type_pos = sub->value_pos + 1; - contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (sub->type_str, - sub->type_pos)); + sub->value_pos = sub->type_pos + sig_len + 1; - sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment); - } + 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", @@ -416,7 +338,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; @@ -521,7 +443,6 @@ 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; @@ -568,8 +489,7 @@ base_reader_next (DBusTypeReader *reader, default: if (!reader->klass->types_only) - (reader->gvariant ? _dbus_marshal_skip_gvariant_basic : _dbus_marshal_skip_basic) ( - reader->value_str, + _dbus_marshal_skip_basic (reader->value_str, current_type, reader->byte_order, &reader->value_pos); @@ -578,41 +498,13 @@ 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; - struct_or_dict_entry_reader_next (reader, current_type); + base_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. @@ -627,23 +519,13 @@ 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; - struct_or_dict_entry_reader_next (reader, current_type); + base_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. @@ -677,26 +559,6 @@ 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 @@ -769,33 +631,12 @@ 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, - body_reader_next + base_reader_next }; static const DBusTypeReaderClass body_types_only_reader_class = { @@ -803,7 +644,7 @@ static const DBusTypeReaderClass body_types_only_reader_class = { TRUE, NULL, /* body is always toplevel, so doesn't get recursed into */ NULL, - body_reader_next + base_reader_next }; static const DBusTypeReaderClass struct_reader_class = { @@ -859,7 +700,7 @@ static const DBusTypeReaderClass variant_reader_class = { FALSE, variant_reader_recurse, NULL, - variant_reader_next + base_reader_next }; #ifndef DBUS_DISABLE_ASSERT @@ -898,7 +739,7 @@ _dbus_type_reader_init (DBusTypeReader *reader, reader->klass = &body_reader_class; reader_init (reader, byte_order, type_str, type_pos, - value_str, value_pos, FALSE); + value_str, value_pos); #if RECURSIVE_MARSHAL_READ_TRACE _dbus_verbose (" type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n", @@ -923,8 +764,7 @@ _dbus_type_reader_init_types_only (DBusTypeReader *reader, reader->klass = &body_types_only_reader_class; reader_init (reader, DBUS_COMPILER_BYTE_ORDER /* irrelevant */, - type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */, - FALSE); + type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */); #if RECURSIVE_MARSHAL_READ_TRACE _dbus_verbose (" type reader %p init types only type_pos = %d remaining sig '%s'\n", @@ -1035,8 +875,7 @@ _dbus_type_reader_read_basic (const DBusTypeReader *reader, t = _dbus_type_reader_get_current_type (reader); - (reader->gvariant ? _dbus_marshal_read_gvariant_basic : _dbus_marshal_read_basic) ( - reader->value_str, + _dbus_marshal_read_basic (reader->value_str, reader->value_pos, t, value, reader->byte_order, @@ -1660,14 +1499,9 @@ _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, @@ -1697,24 +1531,6 @@ _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. * @@ -1782,19 +1598,12 @@ _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer, const void *value) { if (writer->enabled) - { - 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); - } + return _dbus_marshal_write_basic (writer->value_str, + writer->value_pos, + type, + value, + writer->byte_order, + &writer->value_pos); else return TRUE; } @@ -1833,7 +1642,6 @@ 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)) @@ -1984,28 +1792,12 @@ writer_recurse_struct_or_dict_entry (DBusTypeWriter *writer, if (writer->enabled) { - 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); - } + 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; @@ -2093,47 +1885,27 @@ writer_recurse_array (DBusTypeWriter *writer, if (writer->enabled) { - if (!writer->gvariant) - { - /* 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"); - } + /* Write (or jump over, if is_array_append) the length */ + sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4); - _dbus_assert (sub->u.array.len_pos == 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); + /* Write alignment padding for array elements * Note that we write the padding *even for empty arrays* * to avoid wonky special cases */ - 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); - } + alignment = element_type_get_alignment (contained_type, contained_type_start); aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment); if (aligned != sub->value_pos) @@ -2152,7 +1924,7 @@ writer_recurse_array (DBusTypeWriter *writer, sub->u.array.start_pos = sub->value_pos; - if (is_array_append && !writer->gvariant) + if (is_array_append) { dbus_uint32_t len; @@ -2165,12 +1937,6 @@ 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 { @@ -2179,7 +1945,7 @@ writer_recurse_array (DBusTypeWriter *writer, sub->u.array.start_pos = sub->value_pos; } - _dbus_assert (sub->gvariant || sub->u.array.len_pos < sub->u.array.start_pos); + _dbus_assert (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 @@ -2246,58 +2012,31 @@ writer_recurse_variant (DBusTypeWriter *writer, /* If we're enabled then continue ... */ - 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"); + 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, @@ -2305,7 +2044,6 @@ 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; } @@ -2378,8 +2116,6 @@ _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, @@ -2428,10 +2164,32 @@ writer_get_array_len (DBusTypeWriter *writer) return writer->value_pos - writer->u.array.start_pos; } -static dbus_bool_t -_dbus_type_writer_unrecurse_write (DBusTypeWriter *writer, - DBusTypeWriter *sub) +/** + * 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 (sub->container_type == DBUS_TYPE_STRUCT) { if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR)) @@ -2442,7 +2200,7 @@ _dbus_type_writer_unrecurse_write (DBusTypeWriter *writer, if (!write_or_verify_typecode (sub, DBUS_DICT_ENTRY_END_CHAR)) return FALSE; } - else if (sub->container_type == DBUS_TYPE_ARRAY && !sub->gvariant) + else if (sub->container_type == DBUS_TYPE_ARRAY) { if (sub->u.array.len_pos >= 0) /* len_pos == -1 if we weren't enabled when we passed it */ { @@ -2466,46 +2224,6 @@ _dbus_type_writer_unrecurse_write (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: * @@ -2565,6 +2283,8 @@ _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 0873c5b8..acbfd731 100644 --- a/dbus/dbus-marshal-recursive.h +++ b/dbus/dbus-marshal-recursive.h @@ -2,7 +2,6 @@ /* 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 * @@ -45,17 +44,10 @@ 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 @@ -79,18 +71,10 @@ 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 { @@ -99,9 +83,6 @@ 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 */ }; @@ -165,11 +146,6 @@ 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); @@ -183,11 +159,6 @@ void _dbus_type_writer_init_values_only (DBusTypeWriter *write dbus_bool_t _dbus_type_writer_write_basic (DBusTypeWriter *writer, int type, const void *value); -dbus_bool_t _dbus_type_writer_write_basic_with_gvariant - (DBusTypeWriter *writer, - int type, - const void *value, - dbus_bool_t gvariant); dbus_bool_t _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer, int element_type, const void *value, diff --git a/dbus/dbus-message-internal.h b/dbus/dbus-message-internal.h index c4530e60..5d6594e3 100644 --- a/dbus/dbus-message-internal.h +++ b/dbus/dbus-message-internal.h @@ -96,23 +96,11 @@ long _dbus_message_loader_get_max_message_size (DBusMessageLoader void _dbus_message_loader_set_max_message_unix_fds(DBusMessageLoader *loader, long n); long _dbus_message_loader_get_max_message_unix_fds(DBusMessageLoader *loader); -void _dbus_message_loader_set_unique_sender_id (DBusMessageLoader *loader, - uint64_t id); -uint64_t _dbus_message_loader_get_unique_sender_id (DBusMessageLoader *loader); typedef struct DBusInitialFDs DBusInitialFDs; DBusInitialFDs *_dbus_check_fdleaks_enter (void); void _dbus_check_fdleaks_leave (DBusInitialFDs *fds); -DBusMessage * _dbus_message_remarshal(DBusMessage *message, dbus_bool_t gvariant); - -DBusMessage * _dbus_generate_local_error_message (dbus_uint32_t serial, - char *error_name, - char *error_msg); - -dbus_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 674716ae..e1578abd 100644 --- a/dbus/dbus-message-private.h +++ b/dbus/dbus-message-private.h @@ -81,7 +81,6 @@ struct DBusMessageLoader unsigned n_unix_fds_allocated; /**< Number of file descriptors this array has space for */ unsigned n_unix_fds; /**< Number of valid file descriptors in array */ #endif - uint64_t unique_sender_id; }; @@ -130,8 +129,6 @@ 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_bool_t _dbus_message_iter_get_args_valist (DBusMessageIter *iter, diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 4952c17c..c6953d02 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -3,7 +3,6 @@ * * 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,8 +37,6 @@ #ifdef HAVE_UNIX_FD_PASSING #include "dbus-sysdeps-unix.h" #endif -#include "dbus-marshal-gvariant.h" -#include "dbus-protocol-gvariant.h" #include @@ -47,8 +44,6 @@ (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); /** @@ -122,8 +117,6 @@ 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 * @@ -142,80 +135,19 @@ 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 (DBusMessage *message, +get_const_signature (DBusHeader *header, const DBusString **type_str_p, int *type_pos_p) { - dbus_bool_t got_signature = FALSE; - if (_dbus_message_is_gvariant (message) && message->locked) + if (_dbus_header_get_field_raw (header, + DBUS_HEADER_FIELD_SIGNATURE, + type_str_p, + type_pos_p)) { - /* 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; - } + *type_pos_p += 1; /* skip the signature length which is 1 byte */ } - 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) + else { *type_str_p = &_dbus_empty_signature_str; *type_pos_p = 0; @@ -241,7 +173,7 @@ _dbus_message_byteswap (DBusMessage *message) _dbus_verbose ("Swapping message into compiler byte order\n"); - get_const_signature (message, &type_str, &type_pos); + get_const_signature (&message->header, &type_str, &type_pos); _dbus_marshal_byteswap (type_str, type_pos, byte_order, @@ -452,11 +384,8 @@ dbus_message_lock (DBusMessage *message) { if (!message->locked) { - 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); + _dbus_header_update_lengths (&message->header, + _dbus_string_get_length (&message->body)); /* must have a signature if you have a body */ _dbus_assert (_dbus_string_get_length (&message->body) == 0 || @@ -736,18 +665,6 @@ 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)) @@ -1225,25 +1142,13 @@ 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, - type, + DBUS_TYPE_UINT32, &reply_serial); } @@ -1257,28 +1162,14 @@ 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, - type, - value)) - { - if (_dbus_message_is_gvariant (message)) - return v_UINT64; - else - return v_UINT32; - } + DBUS_TYPE_UINT32, + &v_UINT32)) + return v_UINT32; else return 0; } @@ -1309,7 +1200,7 @@ dbus_message_finalize (DBusMessage *message) } static DBusMessage* -dbus_message_new_empty_header (dbus_bool_t gvariant) +dbus_message_new_empty_header (void) { DBusMessage *message; dbus_bool_t from_cache; @@ -1354,8 +1245,6 @@ dbus_message_new_empty_header (dbus_bool_t gvariant) 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); @@ -1380,33 +1269,36 @@ dbus_message_new_empty_header (dbus_bool_t gvariant) } } - message->signature = NULL; - message->unique_sender = NULL; - return message; } -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) +/** + * 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) { DBusMessage *message; - _dbus_assert (message_type != DBUS_MESSAGE_TYPE_INVALID); + _dbus_return_val_if_fail (message_type != DBUS_MESSAGE_TYPE_INVALID, NULL); - message = dbus_message_new_empty_header (gvariant); + message = dbus_message_new_empty_header (); if (message == NULL) return NULL; - if (!(_dbus_message_is_gvariant(message) ? _dbus_header_gvariant_create : _dbus_header_create) (&message->header, + if (!_dbus_header_create (&message->header, DBUS_COMPILER_BYTE_ORDER, message_type, - destination, path, interface, member, error_name)) + NULL, NULL, NULL, NULL, NULL)) { dbus_message_unref (message); return NULL; @@ -1415,42 +1307,6 @@ _dbus_message_create_protocol_version (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 @@ -1478,6 +1334,8 @@ 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 || @@ -1487,8 +1345,20 @@ 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); - return _dbus_message_create(DBUS_MESSAGE_TYPE_METHOD_CALL, - destination, path, iface, 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; } /** @@ -1510,11 +1380,19 @@ dbus_message_new_method_return (DBusMessage *method_call) /* sender is allowed to be null here in peer-to-peer case */ - message = _dbus_message_create (DBUS_MESSAGE_TYPE_METHOD_RETURN, - sender, NULL, NULL, NULL, 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_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, @@ -1555,11 +1433,19 @@ 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_create (DBUS_MESSAGE_TYPE_SIGNAL, - NULL, path, iface, name, 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_SIGNAL, + NULL, path, iface, name, NULL)) + { + dbus_message_unref (message); + return NULL; + } + dbus_message_set_no_reply (message, TRUE); return message; @@ -1598,11 +1484,19 @@ dbus_message_new_error (DBusMessage *reply_to, * when the message bus is dealing with an unregistered * connection. */ - message = _dbus_message_create (DBUS_MESSAGE_TYPE_ERROR, - sender, NULL, NULL, NULL, error_name); + message = dbus_message_new_empty_header (); 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, @@ -1705,7 +1599,6 @@ 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)) { @@ -2174,24 +2067,19 @@ 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, &type_str, &type_pos); + get_const_signature (&message->header, &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); - - if (_dbus_message_is_gvariant (message)) - _dbus_type_reader_gvariant_init (&real->u.reader, message); + _dbus_header_get_byte_order (&message->header), + type_str, type_pos, + &message->body, + 0); return _dbus_type_reader_get_current_type (&real->u.reader) != DBUS_TYPE_INVALID; } @@ -2544,12 +2432,10 @@ 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_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)); + _dbus_type_writer_init_types_delayed (&real->u.writer, + _dbus_header_get_byte_order (&message->header), + &message->body, + _dbus_string_get_length (&message->body)); } /** @@ -2588,21 +2474,11 @@ _dbus_message_iter_open_signature (DBusMessageRealIter *real) if (current_sig) { int current_len; - int additional_size_for_len = 0; - 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); - } + current_len = _dbus_string_get_byte (current_sig, current_sig_pos); + current_sig_pos += 1; /* move on to sig data */ - if (!_dbus_string_init_preallocated (str, current_len + additional_size_for_len)) + if (!_dbus_string_init_preallocated (str, current_len + 4)) { dbus_free (str); return FALSE; @@ -3636,9 +3512,6 @@ 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, @@ -3673,7 +3546,7 @@ dbus_message_get_signature (DBusMessage *message) _dbus_return_val_if_fail (message != NULL, NULL); - get_const_signature (message, &type_str, &type_pos); + get_const_signature (&message->header, &type_str, &type_pos); return _dbus_string_get_const_data_len (type_str, type_pos, 0); } @@ -4274,33 +4147,18 @@ load_message (DBusMessageLoader *loader, /* 2. VALIDATE BODY */ if (mode != DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY) { - 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); - } + 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 (validity != DBUS_VALID) { _dbus_verbose ("Failed to validate message body code %d\n", validity); @@ -4419,31 +4277,6 @@ 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. @@ -4466,7 +4299,6 @@ _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, @@ -4475,14 +4307,13 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) &header_len, &body_len, &loader->data, 0, - _dbus_string_get_length (&loader->data), - &is_gvariant)) + _dbus_string_get_length (&loader->data))) { DBusMessage *message; _dbus_assert (validity == DBUS_VALID); - message = dbus_message_new_empty_header (is_gvariant); + message = dbus_message_new_empty_header (); if (message == NULL) return FALSE; @@ -4497,12 +4328,6 @@ _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); } @@ -4673,17 +4498,6 @@ _dbus_message_loader_get_max_message_unix_fds (DBusMessageLoader *loader) return loader->max_message_unix_fds; } -void _dbus_message_loader_set_unique_sender_id (DBusMessageLoader *loader, - uint64_t id) -{ - loader->unique_sender_id = id; -} - -uint64_t _dbus_message_loader_get_unique_sender_id (DBusMessageLoader *loader) -{ - return loader->unique_sender_id; -} - static DBusDataSlotAllocator slot_allocator = _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (message_slots)); @@ -4990,7 +4804,6 @@ 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; @@ -5007,8 +4820,7 @@ dbus_message_demarshal_bytes_needed(const char *buf, &header_len, &body_len, &str, 0, - len, - &is_gvariant); + len); _dbus_string_free (&str); if (validity == DBUS_VALID) @@ -5023,224 +4835,6 @@ dbus_message_demarshal_bytes_needed(const char *buf, } } -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 007a2d8c..4fd44dab 100644 --- a/dbus/dbus-message.h +++ b/dbus/dbus-message.h @@ -2,7 +2,6 @@ /* 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 * @@ -50,72 +49,21 @@ typedef struct DBusMessageIter DBusMessageIter; * DBusMessageIter struct; contains no public fields. */ struct DBusMessageIter -{ /* 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; +{ + 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 */ }; DBUS_EXPORT @@ -354,9 +302,6 @@ DBUS_EXPORT int dbus_message_demarshal_bytes_needed (const char *str, int len); -DBUS_EXPORT -void dbus_set_protocol_version (unsigned char version); - /** @} */ DBUS_END_DECLS diff --git a/dbus/dbus-pending-call.c b/dbus/dbus-pending-call.c index ed96242e..be534105 100644 --- a/dbus/dbus-pending-call.c +++ b/dbus/dbus-pending-call.c @@ -367,9 +367,6 @@ _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 deleted file mode 100644 index c01f9235..00000000 --- a/dbus/dbus-protocol-gvariant.h +++ /dev/null @@ -1,56 +0,0 @@ -/* -*- 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 b16d35e7..5371d886 100644 --- a/dbus/dbus-shared.h +++ b/dbus/dbus-shared.h @@ -120,8 +120,6 @@ 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 deleted file mode 100644 index e0496b17..00000000 --- a/dbus/dbus-signals.c +++ /dev/null @@ -1,1633 +0,0 @@ -/* 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 deleted file mode 100644 index da3fd57f..00000000 --- a/dbus/dbus-signals.h +++ /dev/null @@ -1,117 +0,0 @@ -/* - * 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 deleted file mode 100644 index cc819cbb..00000000 --- a/dbus/dbus-transport-kdbus.c +++ /dev/null @@ -1,4000 +0,0 @@ -/* -*- 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_array_of_bytes (&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 deleted file mode 100644 index 75818f15..00000000 --- a/dbus/dbus-transport-kdbus.h +++ /dev/null @@ -1,34 +0,0 @@ -/* -*- 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 f6a5d501..396f0ffd 100644 --- a/dbus/dbus-transport-protected.h +++ b/dbus/dbus-transport-protected.h @@ -71,11 +71,6 @@ 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, @@ -114,10 +109,6 @@ 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 */ @@ -132,18 +123,8 @@ 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 eacc6b89..ecc31827 100644 --- a/dbus/dbus-transport.c +++ b/dbus/dbus-transport.c @@ -2,7 +2,6 @@ /* 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 * @@ -33,9 +32,6 @@ #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 @@ -89,58 +85,6 @@ live_messages_notify (DBusCounter *counter, _dbus_transport_unref (transport); } -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 @@ -152,15 +96,13 @@ _dbus_transport_default_get_unix_process_id (DBusTransport *transport, * @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. */ -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) +dbus_bool_t +_dbus_transport_init_base (DBusTransport *transport, + const DBusTransportVTable *vtable, + const DBusString *server_guid, + const DBusString *address) { DBusMessageLoader *loader; DBusAuth *auth; @@ -175,13 +117,7 @@ _dbus_transport_init_base_with_auth (DBusTransport *transport, if (server_guid) auth = _dbus_auth_server_new (server_guid); else - { - if (with_auth) - auth = _dbus_auth_client_new (); - else - auth = _dbus_auth_client_new_authenticated (); - } - + auth = _dbus_auth_client_new (); if (auth == NULL) { _dbus_message_loader_unref (loader); @@ -267,68 +203,9 @@ _dbus_transport_init_base_with_auth (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. @@ -470,9 +347,6 @@ 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 } @@ -1425,47 +1299,6 @@ _dbus_transport_get_max_received_unix_fds (DBusTransport *transport) return transport->max_live_messages_unix_fds; } -/** - * 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(). * @@ -1477,9 +1310,26 @@ dbus_bool_t _dbus_transport_get_unix_user (DBusTransport *transport, unsigned long *uid) { - if (transport->get_unix_user_function == NULL) + 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; - return (transport->get_unix_user_function) (transport, uid); } /** @@ -1493,9 +1343,26 @@ dbus_bool_t _dbus_transport_get_unix_process_id (DBusTransport *transport, unsigned long *pid) { - if (transport->get_unix_process_id_function == NULL) + 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; - return (transport->get_unix_process_id_function) (transport, pid); } /** diff --git a/dbus/dbus-transport.h b/dbus/dbus-transport.h index 0c9458d1..80fa24ef 100644 --- a/dbus/dbus-transport.h +++ b/dbus/dbus-transport.h @@ -98,10 +98,6 @@ dbus_bool_t _dbus_transport_set_auth_mechanisms (DBusTransport void _dbus_transport_set_allow_anonymous (DBusTransport *transport, dbus_bool_t value); -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 deleted file mode 100644 index facd45a2..00000000 --- a/dbus/kdbus-common.c +++ /dev/null @@ -1,1026 +0,0 @@ -/* -*- 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 deleted file mode 100644 index cea606e0..00000000 --- a/dbus/kdbus-common.h +++ /dev/null @@ -1,197 +0,0 @@ -/* -*- 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 deleted file mode 100644 index 4fc44cb1..00000000 --- a/dbus/kdbus.h +++ /dev/null @@ -1,984 +0,0 @@ -/* - * 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 b63ee7f9..e77c13e4 100644 --- a/packaging/dbus-x11.spec +++ b/packaging/dbus-x11.spec @@ -1,5 +1,4 @@ %bcond_with x -%bcond_with kdbus Name: dbus-x11 %define _name dbus @@ -75,9 +74,6 @@ export V=1 --enable-doxygen-docs \ %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} \ diff --git a/packaging/dbus.spec b/packaging/dbus.spec index 2919332b..860d70c3 100644 --- a/packaging/dbus.spec +++ b/packaging/dbus.spec @@ -1,7 +1,5 @@ %define dbus_user_uid 81 -%bcond_with kdbus - Name: dbus Url: http://dbus.freedesktop.org/ Summary: D-Bus Message Bus System @@ -91,9 +89,6 @@ export V=1 --enable-doxygen-docs \ %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} \ diff --git a/packaging/libdbus.spec b/packaging/libdbus.spec index 0494b8cc..26604810 100644 --- a/packaging/libdbus.spec +++ b/packaging/libdbus.spec @@ -1,5 +1,3 @@ -%bcond_with kdbus - Name: libdbus Url: http://dbus.freedesktop.org/ Summary: Library package for D-Bus @@ -70,9 +68,6 @@ 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 -- cgit v1.2.3